Frameworks Were a Constraint Hack
Frameworks solved yesterday’s bottlenecks. Agents change the bottleneck.
From first principles, frameworks are tools for managing constraints:
- limited engineering time
- expensive iteration
- fragile deployments
- inconsistent patterns across teams
Frameworks didn’t win because they were spiritually correct. They won because they made a certain kind of work cheaper and safer under old constraints.
Agents change the constraint landscape.
The new bottleneck isn’t typing code
With capable models, the limiting factor is no longer keystrokes. It’s:
- specifying intent precisely
- enforcing constraints consistently
- verifying outcomes reliably
- maintaining durable state across runs
In other words: the bottleneck is orchestration and proof.
What becomes a “framework” in an agent-first world
You still need structure. But it can live at a higher level than runtime libraries.
The new “framework” is:
- your prompt contracts (outcome, constraints, artifacts, proof)
- your repo conventions (where state lives, how it’s updated)
- your review loop (diffs, checks, approvals)
That’s why you can start many projects without picking a heavy framework at all:
- writing a marketing operating system
- generating landing page copy and experiments
- building outreach sequences
- planning and running events
- producing structured research and briefs
Files and conventions are sufficient.
When frameworks still matter
When the outcome requires a human-facing interactive system (a web app, a dashboard, a mobile app), you’ll still want frameworks. They’re great at:
- routing
- UI composition
- state management
- deployment defaults
The shift is: you choose frameworks when the surface area demands it, not when the habit demands it.
The practical takeaway
Ask one question before you pick a stack:
“What is the smallest container that can hold the outcome, constraints, artifacts, and proof?”
Sometimes the answer is Next.js. Sometimes it’s a repo full of structured files.
Agents don’t remove the need for structure. They move structure up a level—from code-first scaffolds to outcome-first contracts.