Anthony Accomazzo

engineering @notionhq | prev founder @sequinstream (acq by Notion)

[Anthony Accomazzo @accomazzo]

My fiancé and I have kept our relationship humming with a simple morning ritual.

Every morning over coffee, we ask each other these three magic questions:

1. Are your CPUs saturated?
2. How's back-pressure?
3. Is your I/O optimally batched?

[Anthony Accomazzo @accomazzo]

@atmoio Yes many complex systems are simple things scaled up (evolution).

But *what that simple thing is* matters.

Just because two systems share that property does not mean they’re the same.

That phrase is vague enough to describe evolution, the brain, calculators, and ant colonies.

[Anthony Accomazzo @accomazzo]

LLMs ingest superhuman amounts of data and unfurl it with superhuman speed and fidelity. It's hard for us to picture how and why that works.

So instead, we (erroneously) map these systems to human reasoning, because that's what we know.

[Anthony Accomazzo @accomazzo]

> "This changes everything."

Your session is cooked and it is irresponsible to waste even one more token on it.

[Anthony Accomazzo @accomazzo]

diabolical unsubscribe flow from @chase

[Anthony Accomazzo @accomazzo]

I'm not sure Pop-Tarts are a good example here, because the explanation is a guess about the creative process of another person's mind, i.e., whoever named the Pop-Tart.

The explanations that Deutsch describes in his book interlock/interface with many other explanations of the universe.

For example, the explanation for why we have seasons interlocks with weather patterns in different regions of the planet, orbital mechanics, the tilt of the earth, the distance between various surfaces of the earth and the sun, etc.

What makes the explanation of the seasons hard to vary is that if you wanted to tweak any property of the explanation, it would have a cascading effect on the other explanations that it interlocks with.

[Anthony Accomazzo @accomazzo]

See you there!

[Notion Developers @NotionDevs]

SF builders: Join us for two days of hands-on building on our new Developer Platform.

Sync any data source into Notion, give your agent any tool, and trigger workflows from anywhere. No servers, no infra. Just a CLI and your ideas.

Space is limited.

Apply here: https://t.co/Dyw2J0VWWH

[Notion Developers @NotionDevs]

Developers: Join us on May 13.

A first look at our new developer platform. Let's build, together.

https://t.co/qR4WXfRX86

[Anthony Accomazzo @accomazzo]

Every generation relearns anthropomorphism.

[Anthony Accomazzo @accomazzo]

I mean, if authority is how you justify belief, then “next-token prediction” probably does look like a strong theory of knowledge

- Tony

[ℏεsam @Hesamation]

DHH is in.
Karpathy is in.
Andrew Ng is in.
Terence Tao is in.
Linus Torvalds is in.
John Carmack is in.

Tony with an opinion still believes AI is just a next-token predictor with no real future.

[Anthony Accomazzo @accomazzo]

Calling that "basically creativity" is like calling Lamarckism "basically Darwinism"

Both describe trait transmission. But *how* they do so is *the* significant bit.

We don't know *how* human creativity works, so we can't say that anything is like it

Searching novel paths through a space is optimization. We have no theory that says creativity is optimization.

[Anthony Accomazzo @accomazzo]

Long AI, short AGI

[Anthony Accomazzo @accomazzo]

The token for "smoking gun" gets emitted and now the model is contractually obligated to deliver one 💀

[Anthony Accomazzo @accomazzo]

"There it is. The smoking gun." 💀

[Anthony Accomazzo @accomazzo]

"There it is. The smoking gun." 💀

[Brian Lovin @brian_lovin]

You know it's bad when you get hit with a "Now I have the full picture."

[Anthony Accomazzo @accomazzo]

@ThepotSimon yes, more on that soon :)

[Anthony Accomazzo @accomazzo]

We just made some big updates to Notion Workers' sync!

There has never been a better platform for building a fast, robust sync. Full-stop.

With our SDK, sync data from any API into Notion dbs. Notion handles scheduling, observability, rate limiting, and your db:

[Anthony Accomazzo @accomazzo]

Excited to announce Notion Workers now support syncs!

Sync any data into a Notion database with a single JavaScript function, from a team roster in a spreadsheet to all your opportunities in Salesforce.

Write the function, deploy to Notion, and we'll handle the rest.

[Anthony Accomazzo @accomazzo]

The rift, of course, is whether you’re building load-bearing software or not.

Line-by-line comprehension is not going anywhere in load-bearing software. Just like it's going nowhere in law, gene editing, or structural engineering.

Sure, many lines of software are boilerplate/ceremonial. But other lines carry all the weight. The `if` clause that determines if the user has permission to operate on the record. The math behind the withdrawal. The `org_id` filter in the SQL statement. Grabbing a mutex before operating on a shared data structure.

“Codex did it” in the incident post-mortem will not fly with your customers. Ultimately, a person needs to be responsible. This would be the case even if the LLMs weren’t as jagged as they are; they have no skin in the game. A person does.

In some software, the stakes and dependencies are low. A Rails blog is fungible across the board. All that really matters is that it looks good, the articles load, the user can navigate the site and make comments. An LLM or a person can achieve each of those things a thousand different ways. Human or machine verification is relatively trivial.

But in most load-bearing software, the stakes and dependencies are high. Precision is paramount. And verification is often difficult; there are just too many possible states and transitions.

Claude can help you change that function to support the new requirement. It can even help you change all its call sites, a previously tedious task. But a person *absolutely* needs to understand what change has taken place, how dozens or hundreds of dependencies will be affected, whether a rollout plan is necessary, etc.

The agent can sum up the change for you. But often for important lines, simply *seeing the code* is the highest-bandwidth way to transmit information about the change. Let alone the most precise.

The lines of code were always a means to an end. The important part has always been the business logic.

And logic is incompressible beyond a point. The reason programming languages will never go away is that your system needs contractual statements an organization can agree on: “this user shall be able to do X, but only if Y and Z.” Those statements often need to be highly precise and deterministic.

Perhaps the right mental model, then: this leap is like going from writing a web app in assembly to writing it in Rails. Rails eliminated a ton of ceremony. But it did not eliminate the need to understand the important bits of your code. LLMs likewise give us incredible ability to operate on these codebases, often akin to using an excavator instead of a shovel. But the contracts are still there, they're still very important, and we're still very responsible for them.

[Elvis @elvissun]

this thread is what mass cope from legacy devs looks like.

i talked to @FastCompany about why @garrytan's "AI slop" is actually the future of software engineering.

the mass code review. the line-by-line gatekeeping. the "craftsmanship" that was really just slow iteration disguised as rigor - that era is over.

and the engineers who built their entire identity around it are panicking.

@gregorein brags about burning 3 billion tokens last year while dunking on garry for flexing lines of code. i've burned 6.6 billion in the past three months on codex alone. by his own logic, i'm 8x as credible.

see how silly that sounds?

yes, he found real issues. yes, they got fixed. that's exactly the point.

karpathy's autoresearch proved this already - AI agents can solve very complex problems just by operating inside feedback loops, iterating to optimize a loss function.

this is what software engineering is now - gradient descent.

ship, measure, self-correct, repeat.

all by the agent itself.

this is the new startup playbook.

your job isn't to review every line before deploy. your job is to build systems where agents observe outcomes - mrr, analytics, error rates, user behavior - and self-improve.

the engineer's role shifts from gatekeeper to building the machine that builds the machine.

you could run this level of audit (using AI) on any production site and find the same issues - most just don't have a billionaire CEO attached for virality.

mocking the people who adapted is easier than adapting.

but the craft is evolving whether you like it or not.

[Anthony Accomazzo @accomazzo]

Notion Workers are in public alpha. Give it a whirl and let me know what you think!

See the README:
https://t.co/IsfZtVQSJF

[Anthony Accomazzo @accomazzo]

Bringing it all together: to setup a CRM sync, you'd implement two functions:

- `contactBackfill`: Runs on a manual schedule. On top of reloading all data from Salesforce into your db, it performs a mark & sweep on each run so stale data is evicted.
- `contactDelta`: Runs every 5min. Incrementally fetches just the changes since its last run.

You'd use a `crmPacer` to ensure requests are spread out evenly.

An example of the lifecycle:

1. Deploy: `ntn workers deploy`. Notion creates the database, initializes tasks
2. Delta runs automatically every 5 min, pulling changes via Salesforce's change data capture
3. Months later, I update my schema mapping. I re-backfill:

`ntn workers sync state reset contactBackfill`

then:

`ntn workers sync trigger contactBackfill`

4. Backfill runs alongside the active delta — no downtime, no conflicts

All the while, Notion handles: database creation, schema migration, scheduling, checkpointing, rate limiting, failure backoff, observability, and deduplication.

You (i.e. your coding agent) just write the fetch logic.