TWITTER_ARTICLE

In a 2026-02-14 X post, Michael Bloch described a startup that called a "war…

2026-02-14 · 14:24 UTC ·michaelxbloch ·4 min read

Brief

Michael Bloch outlines an agent-first engineering playbook derived from a startup that restructured its workflow after Claude Code made its previous operating model obsolete. The core change is organizational rather than merely tactical: engineers no longer focus on writing as much code as possible, but on setting up agents with clear objectives, constraints, and success metrics so the agents can execute autonomously. The team now blocks the first 1-2 hours of each morning for collaborative prompt design and alignment, then evaluates agent-generated work by whether it satisfies the objective rather than by inspecting every line. The post also argues for designing systems for AI consumption, with clean data artifacts, explicit conventions, and minimal dead code because the codebase itself becomes model context. Additional principles include maximizing agent utilization during off-hours, standardizing interfaces rather than personal workflows, avoiding lock-in, and assuming tools and best practices will change within roughly three months.

Why it matters

In a 2026-02-14 X post, Michael Bloch described a startup that called a "war room" after Claude Code broke its prior engineering workflow and replaced its old playbook with an agent-first model in which engineers spend mornings drafting prompts, objectives, and constraints before agents begin work.

Key details

  • The team’s most visible operating change is "no coding before 10am": engineers use the first 1-2 hours each morning to pair prompt, align on goals, and define success criteria, reversing the long-standing engineering norm of maximizing uninterrupted coding time.
  • The playbook treats AI agents as the primary user of systems: code is framed as context rather than a reusable library, data artifacts are treated as the real interface between components, and dead code paths are removed immediately because they degrade agent performance by adding noise to the codebase context.
  • Specification shifts from implementation plans to objective functions: each task should be expressible in one sentence with explicit constraints and success criteria, teams should "review the output, not the code," and traditional PRDs and line-by-line code review are portrayed as lower-value overhead in an agent-driven workflow.
  • The startup optimizes for agent utilization and human time rather than compute cost, arguing that idle agents are waste, that agents should run overnight and asynchronously, and that spending 10x more tokens is justified if it saves a day of human decision-making; the post predicts teams that fail to rebuild around agents will be outshipped by teams half their size within six months.
Source evidence

title: @michaelxbloch: A startup I work with just scrapped their entire playbook. They've been making f...
author: michaelxbloch
contenttype: twitterarticle
published: 2026-02-14T14:24:53+00:00
source_url: https://x.com/michaelxbloch/status/2022678437362598163

word_count: 865

A startup I work with just scrapped their entire playbook. They've been making fast progress, but ov

A startup I work with just scrapped their entire playbook. They've been making fast progress, but over the last month their way of working broke because of Claude Code. They called a war room and rebuilt how they operate from scratch.

Their first new rule: no coding before 10am. For twenty years, engineering culture has been about maximizing time spent writing code. Kill meetings. Block calendars. Stop anything that pulls an engineer away from coding. This team is doing the opposite. Every morning, engineers now pair prompt. They sit together, draft prompts, define objectives, and set agents up to succeed. Only after that do the agents start working.

Their playbook is not “use AI to code faster.” It’s a full inversion. Agents, not engineers, now do the work. Engineers make sure the agents can do the work well. I’ve seen dozens of teams operate over the last decade, from DoorDash to my own startup. What they came up with is the clearest version I've seen of how engineering actually works now. I asked if I could share it. Here's their playbook:

Agents Are the Primary User

  • Build

  • for

  • agents,

  • not

  • humans.

  • Every system, data store, naming convention, and knowledge artifact should be designed for an AI agent as the primary consumer. Humans interact with systems through agents whenever possible.

  • Code

  • is

  • context,

  • not

  • a

  • library.

  • Agents read code to understand what it does, then regenerate their own version. Don’t optimize for code reuse across people. Optimize for code comprehensibility by an agent. Code itself is now the documentation.

  • Data

  • is

  • the

  • real

  • interface.

  • The right interface between two components is a well-structured data artifact, not a function call. Clean data lets agents compose systems without being told how.

  • Maximize

  • agent

  • utilization.

  • If the team is commuting and nothing is running, that’s waste. Agents should work overnight, on commutes, in meetings, asynchronously. The most expensive thing in the system is now an agent / compute sitting idle while it waits for a human.

How We Spec and Build

  • Objective

  • and

  • constraints

  • first.

  • Before building anything: write the objective in one sentence, list the constraints, define success criteria. If you can’t state the objective in one sentence, you don’t understand the problem well enough to build it.

  • Don’t

  • spec

  • the

  • process,

  • spec

  • the

  • outcome.

  • AI figures out the process. You judge output against the objective function. This replaces traditional PRDs. Write objective functions, not implementation plans.

  • Define rules, not structure.

  • Don’t over-specify schemas and formats. Set naming conventions, metadata requirements, and versioning rules. Let agents figure out the rest.

  • Review the output, not the code.

  • Don't read every line an agent writes. Test code against the objective. If it passes, ship it. If it doesn't, reset the objectives & constraints. Code review as we knew it is overhead the system no longer needs.

  • When

  • you

  • build

  • a

  • new

  • way,

  • kill

  • the

  • old

  • way.

  • No parallel implementations. Old code paths get removed immediately. The codebase is agent context. Every dead path is noise that degrades agent performance.

  • Think in systems.

  • If you’re doing something manually more than twice, automate it. If a human is repeating a task, the system isn’t set up right. The goal is: set things up, let them run, check the output, move on.

Working Together

  • No

  • coding

  • before

  • 10am.

  • Hands off keyboards. First hour or two every morning is for talking, aligning, and drafting prompts together. Once the team is aligned on what to build and how to set agents up, then you can code and let agents start working.

  • Optimize

  • for

  • time,

  • not

  • tokens.

  • If 10x more tokens saves a day, spend the tokens. The bottleneck is human decision-making time, not compute cost.

  • Individual

  • autonomy,

  • shared

  • interfaces.

  • Everyone uses their own IDE, prompting style, and workflow. What gets standardized: data patterns, objective specs, component responsibilities. Everything else is personal choice.

  • Point

  • out

  • anti-patterns

  • immediately.

  • When you catch yourself or someone else falling into old habits, building for humans instead of agents, accumulating dead code, skipping specs, flag it. Old habits compound fast.

  • Assume

  • everything

  • changes

  • in

  • 3

  • months.

  • Technology shifts monthly now. Every decision you make today will soon be wrong. Build modular. Minimize lock-in at every level.

Six months from now, there will be two kinds of engineering teams: ones that rebuilt how they work from first principles, and ones still trying to make agents fit into their old playbook. The second group will get outshipped by teams half their size.

If you run an engineering team and you haven’t had your version of this war room yet, have the meeting. Throw out the playbook. Write the new one.

What would your team’s tenets look like? I’d genuinely love to hear.

Posted: 2026-02-14T14:24:53.000Z

Engagement: 865 likes, 92 retweets, 33 replies