上午 10 点前不写代码

我合作的一家创业公司刚刚扔掉了他们的整个工作手册。他们一直在快速推进，但过去一个月，他们的工作方式因为 Claude Code 和 Codex 彻底崩溃了。于是他们开了一个作战室会议，从零重建了如何运作。

他们的第一条新规则：上午 10 点前不写代码。

过去二十年，工程文化一直在追求最大化写代码的时间。砍会议。锁日历。阻止任何让工程师离开键盘的事情。这个团队在做完全相反的事。每天早上，工程师们现在一起 pair prompt：他们坐在一起，起草 prompt，定义目标，把 Agent 设置好让它能成功。只有在这之后，Agent 才开始工作。

他们的手册不是“用 AI 更快地写代码“。它是一个彻底的翻转。Agent，而不是工程师，现在是干活的人。工程师确保 Agent 能把活干好。 在过去十年里，我见过几十个团队的运作方式——从 DoorDash 到我自己的创业公司。他们总结出的东西，是我见过的关于“工程现在到底是怎么运作的“最清晰的版本。我问能不能分享。以下是他们的手册。

Agent 是首要用户

1. 为 Agent 设计，不是为人。 每一个系统、数据存储、命名约定和知识产物，都应该以 AI Agent 作为首要消费者来设计。人类尽可能通过 Agent 与系统交互。

2. 代码是上下文，不是库。 Agent 读代码来理解它做什么，然后生成自己的版本。不要优化“跨人的代码复用“。优化“Agent 对代码的可理解性“。代码本身就是文档。

3. 数据是真正的接口。 两个组件之间的正确接口是结构良好的数据产物，而不是函数调用。干净的数据让 Agent 能自己组合系统，不需要被告诉怎么做。

4. 最大化 Agent 利用率。 如果团队在通勤而什么都没在跑，那是浪费。Agent 应该在夜间工作、在通勤时工作、在会议中工作、异步工作。系统里最贵的东西，是 Agent/算力坐在那里等待一个人。

如何 Spec 和 Building

1. 目标和约束先于一切。 在建造任何东西之前：用一句话写出目标，列出约束，定义成功标准。如果你不能在一句话里说清目标，那你就没有足够理解这个问题来建造它。

2. Spec 结果，不是过程。 AI 自己想办法。你根据目标函数判断输出。这取代了传统的 PRD。写目标函数，不要写实现计划。

3. 定义规则，不是结构。 不要过度指定 schema 和格式。设定命名约定、元数据要求和版本规则。让 Agent 自己搞定剩下的。

4. 审查输出，不是代码。 不要读 Agent 写的每一行代码。根据目标测试代码。通过就发布。不通过就重新设定目标和约束。代码审查，作为我们曾经知道的那个东西，是这个系统不再需要的开销。

5. 当你建立了一种新方式，杀掉旧方式。 不要并行实现。旧代码路径立即移除。代码库是 Agent 的上下文。每一条死路径都是噪音，会降低 Agent 的性能。

6. 用系统思维思考。 如果你手动做某件事超过两次，自动化它。如果一个人还在重复一个任务，那就是系统没设好。目标是：把事情设好，让它们跑起来，检查输出，继续前进。

一起工作

1. 上午 10 点前不写代码。 手离开键盘。每天早上的一两个小时是用来交谈、对齐、一起起草 prompt 的。一旦团队就在建造什么、怎么设置 Agent 达成了共识，然后你再开始写代码，让 Agent 开始工作。

2. 优化时间，不是 token。 如果花 10 倍的 token 能省一天时间，花。瓶颈是人类的决策时间，不是计算成本。

3. 个人自主，共享接口。 每个人用自己的 IDE、自己的 prompting 风格、自己的工作流。标准化的是：数据模式、目标规格、组件职责。其他一切是个人选择。

4. 立刻指出反模式。 当你发现自己或别人在掉回旧习惯——为人类设计而不是为 Agent、积累死代码、跳过 spec——立刻指出来。旧习惯积累得极快。

5. 假设一切在三个月内变化。 技术现在每个月都在变。你今天做的每一个决定很快就会错。模块化构建。在每一个层面最小化锁定。

六个月后，会有两种工程团队：从第一性原理重建了工作方式的，和还在试图把 Agent 塞进旧手册的。后者会被规模只有自己一半的团队远远甩在后面。

如果你管着一个工程团队，还没开过你自己版本的这种作战室会议，去开。扔掉旧手册。写新的。

原文：Michael Bloch, No Coding Before 10am, Feb 2026 https://michaelxbloch.substack.com/p/no-coding-before-10am…

#AI工程 #Agent #软件工程 #工作方式

No Coding Before 10am | Michael Bloch

Source: https://michaelxbloch.substack.com/p/no-coding-before-10am 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 and Codex. So 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

1. **Buildforagents,nothumans.**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.
2. **Codeiscontext,nota****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.
3. **Dataistherealinterface.**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.
4. **Maximizeagentutilization.**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.

HowWeSpecandBuild

1. **Objectiveandconstraints****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.
2. **Don’tspectheprocess,spectheoutcome.**AI figures out the process. You judge output against the objective function. This replaces traditional PRDs. Write objective functions, not implementation plans.
3. **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.
4. **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.
5. **Whenyoubuildanewway,killtheold****way.**No parallel implementations. Old code paths get removed immediately. The codebase is agent context. Every dead path is noise that degrades agent performance.
6. **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

1. **Nocodingbefore****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.
2. **Optimizefortime,nottokens.**If 10x more tokens saves a day, spend the tokens. The bottleneck is human decision-making time, not compute cost.
3. **Individual****autonomy,sharedinterfaces.**Everyone uses their own IDE, prompting style, and workflow. What gets standardized: data patterns, objective specs, component responsibilities. Everything else is personal choice.
4. **Pointoutanti-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.
5. **Assumeeverythingchangesin3****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.