Anthony 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?

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.

> "This changes everything." Your session is cooked and it is irresponsible to waste even one more token on it.

diabolical unsubscribe flow from @chase

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.

You probably missed this in The Beginning of Infinity by David Deutsch

See you there!

Developers: Join us on May 13. A first look at our new developer platform. Let's build, together. ntn.so/developers

Every generation relearns anthropomorphism.

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

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.

And I don’t think you understand how a transformer network learns and how RL can optimise it to search for novel paths not only in language space but in any different spaces which is basically creativity. This will be more clear in the near future , then again people will still say it’s not.

Someone out there seems to know that an LLM is not an AGI, nor will better LLMs ever be AGIs.

Long AI, short AGI

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

"There it is. The smoking gun." 💀

@ThepotSimon yes, more on that soon :)

@accomazzo Is it backed by sequin/elixir code ?

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:

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.

Notion Workers are in public alpha. Give it a whirl and let me know what you think! See the README: github.com/makenotion/wor…

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.