Self-driving products
Both PostHog and Amplitude are pivoting into "self-driving products", or agents modifying the codebase based on what they observe from the system. TBD whether this produces better outcomes — do PostHog and Amplitude using self-driving themselves produce outsized returns?
Tokens as a proxy for value
I’m struck by one thing. Imagine for a moment that we understood team funding as a combination of salaries and AI spend. A team might look at itself and say, “Geez, we cost $1.5M a year in salaries plus $1M in tokens. What is our business case here?”
I understand that this is somewhat utopian. In many companies, the goal is explicitly to use AI to eliminate some portion of that team, its managers, or the surrounding organization, based on some substitution math.
But if you think about the problem at the level of the team + AI system, the solution is remarkably similar to the “alternative” described above. What demand are we serving? What causal model connects our work to differentiated value? What durable areas are we investing in? What assumptions have to hold? What evidence would make us increase, decrease, or redirect the investment?
John Cutler, TBM 437: Tokens, Hours, Points, and Other Curious Proxies
Articulated as a set of statements:
- We believe using AI for __________ will reduce __________ without materially increasing __________.
- We believe AI will primarily augment/replace __________, resulting in __________.
- We believe spending __________ on AI will be economically preferable to __________ because __________.
- We believe making __________ cheaper/faster will not simply move the bottleneck to __________.
- We believe increased AI-enabled production of __________ can be absorbed without creating excessive __________.
- We believe the primary long-term asset created by this AI investment will be __________, rather than merely cheaper production.
- We believe the human + AI system will outperform __________ on __________, after accounting for __________.
- We believe the downstream costs of AI-generated __________ will remain below __________ over its useful lifetime.
- We believe paying a premium for __________ will produce enough additional __________ to justify the premium.
- We believe this investment works economically only if __________ remains true and __________ does not become the limiting constraint.
Agentic verification
I personally feel that agentic verification is so important that I would unironically suggest building your own rich debugging tools, or even choosing a different tech stack, in order to have unfair advantages and extreme productivity in building software. As I mentioned earlier, giving agents the ability to verify their own work unlocks everyone in your organization to be able to contribute and validate that their changes actually work. The harder your tech stack is to debug and control, the more difficult it will be to use agents productively.
Lauren Tan, The Complete Guide to pstack Pt. 1
Anthropic's AI-native SDLC playbook
Anthropic published an AI-Native SDLC playbook that starts from the same premise as this page: "Code is no longer the bottleneck—the human-speed steps around it are." Its six stages (Plan, Design, Build, Test, Deploy, Maintain) map closely onto Identify, Define, Execute, Verify, Release, and Learn, and both treat delivery as a loop in which humans keep the decisions that require judgment.
| Anthropic |
This page |
How they compare |
| Plan |
Identify |
The playbook captures an idea as intent.md right away and measures time to the first commit. This page starts earlier, with deciding which signals are worth acting on and when there's enough evidence to commit capacity. |
| Design |
Define |
The playbook collapses requirements and design into one AI session, constrained by policy skills, which a product owner reviews. This page shapes the work with an appetite, rabbit holes, and no-gos, and deliberately leaves room for judgment during execution. |
| Build |
Execute |
The playbook requires an accepted plan.md before implementation and scales through parallel sessions per engineer. This page focuses on decomposing work into coherent, reviewable changes and keeping work in progress within review capacity. |
| Test |
Verify |
The playbook has each session check its own work, with evals in CI. This page asks whether a change is correct, secure, understandable, and altruistic, combines deterministic, agentic, and human checks, and treats human review capacity as the likely constraint. The playbook puts AI code review in Deploy; this page puts it in Verify. |
| Deploy |
Release |
The playbook enforces approval through hooks and tiered autonomy, where the agent "may act up to the production gate and cannot pass it." This page separates deploying from releasing, using feature flags and staged rollout to manage customer exposure. |
| Maintain |
Learn |
The playbook has monitoring breaches invoke an agent, which writes its diagnosis back as a new intent.md. This page interprets usage, feedback, and support signals to decide what to do next, and applies the learning to the delivery system as well as the product. |
Beyond the stages, the two diverge in two places.
The prescribed chain of markdown files isn't durable. In the playbook, every stage commits an artifact the next stage reads: intent.md, then spec.md, then plan.md, with CLAUDE.md and REVIEW.md alongside. That's a good audit trail for a single change, but it doesn't hold up as a description of the software:
- Each file is a snapshot of one change at one moment. Once the code merges, nothing keeps
spec.md true. The next change to the same behavior writes a new spec, and the old one quietly goes stale. The playbook's own metrics hint at this, since it tracks how often the merged diff still matches the committed plan.md.
- The files are organized around changes, not around the system. To learn how a feature is supposed to behave, you'd have to reassemble it from every intent, spec, and plan that ever touched it.
- The playbook offers a legacy tracker as an alternative source of truth, which suggests the files aren't meant to be the system of record either.
What should endure is the software's contract: what it's meant to do, kept in a place that tests, reviews, and agents can check against. What that system of record looks like is still an open question on this page.
It doesn't address how people develop a shared understanding. The playbook's governance has three layers: skills (advisory), hooks (deterministic), and human review (judgment). Each one is a control on a single change. None of them covers how a team comes to agree on the problem, the architecture, or what "good" looks like.
- A product owner reviews the spec rather than writing it. Reacting is faster than producing, but approving an artifact isn't the same as a team agreeing on it.
- AI makes code cheap and architecture the hard part. When engineers don't agree on an approach before implementation, code review turns into nitpicking at best and a restart at worst.
- The playbook measures concurrent sessions per engineer. That's single-player mode. Multi-player mode, where several people and agents work on the same system, depends on ceremonies that build shared context: design walkthroughs, recorded talks about decisions, and decision records discussed before they're written down.