No. 116Product strategy

No Silver Bullet

Your agents write the code in minutes. The week goes to deciding what the code should do.

Here is one engineer's work log for one feature, at an invented company:

Mon 09:30. Picked up "Let sales extend free trials." Asked the coding agent for a plan.

Mon 09:52. Agent's pull request is up: an endpoint, an admin button, tests. All green.

Mon 10:05. Review question: how many times can a trial be extended? The ticket doesn't say. Asked in the sales channel.

Mon 14:40. Sales says as many times as a deal needs. Finance, in the same thread, says once, because extensions push out revenue. Nobody decides.

Tue 11:00. Asked product. The PM remembers a decision last quarter about extensions, but can't find it.

Tue 16:20. Found it in a March Jira comment: extensions only for trials with an open sales opportunity, 14 days at most. It was never linked to this ticket.

Wed 09:15. Agent rewrote the pull request in 12 minutes.

Wed 13:30. Support asks what happens when sales extends a trial that has already expired. The March comment doesn't cover it. Back to product.

Thu 17:00. Still waiting.

Fri 10:10. Decided: expired trials can't be extended, sales starts a new trial instead. Agent updated the pull request in 8 minutes. Merged.

The code took about 40 minutes of agent time across the week. Everything else in the log is someone working out what the code should do.

A computer scientist predicted this shape of week in 1986.

Essence and accident

Fred Brooks, who managed the development of IBM's System/360 and wrote The Mythical Man-Month, wrote "No Silver Bullet: Essence and Accidents of Software Engineering" in 1986. He presented it at that year's IFIP World Computer Congress and issued it as a University of North Carolina technical report, and IEEE Computer published it in April 1987. The quotations here are from the 1987 Computer text, checked against the 1986 report.

His argument starts with a split. In the section on essential difficulties, Brooks divides software's difficulties, "following Aristotle," into essence, "the difficulties inherent in the nature of software," and accidents, "those difficulties that today attend its production but are not inherent."

The essence is what the software is: "a construct of interlocking concepts: data sets, relationships among data items, algorithms, and invocations of functions." The accident is writing that construct down in a language a machine can run. Brooks puts the weight on the first: "I believe the hard part of building software to be the specification, design, and testing of this conceptual construct, not the labor of representing it and testing the fidelity of the representation."

He names four properties that make the essence hard. Two of them read like the work log. Conformity: much of the complexity an engineer faces "is arbitrary complexity, forced without rhyme or reason by the many human institutions and systems to which his interfaces must conform." Changeability: software is "embedded in a cultural matrix of applications, users, laws, and machine vehicles," and all of those keep changing. Finance's revenue rule and sales's deals are that matrix.

Every past breakthrough removed the accident

The next section is titled "Past Breakthroughs Solved Accidental Difficulties." High-level languages, time-sharing and unified programming environments each made programmers far more productive, and each, Brooks argues, did it by removing difficulty that was never in the problem. Of high-level languages he writes that the language "eliminates a whole level of complexity that was never inherent in the program at all."

That is also why he expected no further breakthrough of that size. In the section on promising attacks, he puts it as arithmetic: "If, as I believe, the conceptual components of the task are now taking most of the time, then no amount of activity on the task components that are merely the expression of the concepts can give large productivity gains."

He looked at artificial intelligence as a candidate too, and did not expect it to deliver. "The hard thing about building software is deciding what one wants to say, not saying it."

What the agents removed

The reading that follows is ours, not Brooks's. A coding agent is the largest attack on the accident so far. It takes a description of the construct and does the labor of representing it, and on a good day it tests the fidelity of the representation too. In the work log, that part of the week shrank to about 40 minutes.

Brooks's arithmetic says what happens next. If the expression goes to nearly zero, the week is whatever remains, and what remains is the essence. The log has almost nothing else in it: an unanswered question, a disagreement between sales and finance, a decision nobody could find, a case nobody had thought of. Our essay on the modern product development lifecycle describes where that work now waits: "The work now piles up at the same review gates, waiting on people."

The hardest single part

Brooks's most quoted line is in the section "Requirements refinement and rapid prototyping": "The hardest single part of building a software system is deciding precisely what to build." He goes on: "No other part of the work so cripples the resulting system if done wrong. No other part is more difficult to rectify later."

He didn't think this part could be done once, up front. "For the truth is, the client does not know what he wants." His remedy was iteration: rapid prototypes, and software grown incrementally, so that people can try a version and find out what they meant. Coding agents make that loop cheaper than Brooks could have imagined. A prototype is minutes away. But each turn of the loop still ends in a decision someone has to make and someone else has to find, which is where the work log spent its week.

His section on program verification makes a related point. Even a perfect proof "can only establish that a program meets its specification. The hardest part of the software task is arriving at a complete and consistent specification, and much of the essence of building a program is in fact the debugging of the specification." Our parallel: passing tests have the same limit. The first pull request in the log was green, and it was the wrong feature.

We've written about the product context layer, which cites the same Brooks essay. The point here is narrower: once the accident is cheap, the decisions are the work.

Where Brief fits: working on the essence

Brief is the product strategy agent. The homepage says it "captures decisions where they happen, connects them into one graph, and acts on them." In Brooks's terms, it doesn't remove the essential difficulty. No tool does. What it can do is keep the decisions that make up the essence where people and agents will find them, so the same question doesn't cost a week twice.

Decisions are recorded with their reasons. In the Brief app, recording a decision requires both What was decided? and Why? before Record Decision will save it, and a decision can also carry Tags and a Re-evaluate when condition. "Trial extensions only for trials with an open sales opportunity, 14 days at most, because extensions push out revenue" is one piece of the conceptual construct. In his section on expert systems, Brooks calls knowledge acquisition "even more difficult and important" than generating diagnostic rules automatically from a program's structure: "finding articulate, self-analytical experts who know why they do things." The Why? field is our small version of asking for that, and the comparison is ours.

Decisions are read from where they were made. The March decision existed. It was in a Jira comment nobody linked to the ticket. The homepage says Brief "reads decisions from Slack, Jira, Confluence, and GitLab, self-hosted included." A rule settled in a ticket comment or a thread doesn't have to wait for someone to remember it.

Agents check before they build. Coding agents set up with Brief search the recorded decisions before they start work, and ask Brief to check significant changes with brief_ask in check mode, which compares a planned change against existing decisions and flags conflicts. An agent asked to let sales extend trials can find the March decision before it opens the first pull request, instead of a day and a half later. People can run the same check with brief ask --mode check.

Open questions go to a named person. The question about expired trials sat for two days because it had no owner. In the app, Propose turns an open question into a pending decision and can name Who should decide?, which records who the question belongs to. With the user's approval, an agent can record a pending decision too, and agents can call brief_list_pending_decisions to see what is waiting. When a decision is pending, an agent can hold. The homepage shows an agent asked to add per-seat pricing to the checkout API learning that D-241, the seat-based pricing decision, is pending, and replying: "Holding the pricing change until D-241 is decided."

Changed decisions stay visible. Brooks's changeability means the construct keeps moving. When a decision changes, its History shows its status changes, and its Re-evaluate when condition says in advance what would justify a new look. With Proactive Brief turned on, Brief can also prompt people to revisit decisions that may need reconfirming.

None of this is a silver bullet, and Brooks would say it can't be one. Brief doesn't decide whether trials can be extended. Sales, finance and product still have to. It only knows the decisions a team records, and when nothing has been recorded, check mode finds no conflict and the agent goes ahead on the ticket alone. What Brief changes is how often the essential work has to be done again. A decision made once, with its reason, can be found by the next person and the next agent instead of rediscovered in a Jira comment.

Brooks's argument was that the hard part was never the typing. Now that your agents do the typing, how much of your team's week goes to deciding things it has already decided once?

Objections

Objection 1

What is "No Silver Bullet"?

"No Silver Bullet: Essence and Accidents of Software Engineering" is an essay by Fred Brooks, first presented in 1986 and issued that year as a University of North Carolina technical report, and published in IEEE Computer in April 1987. It argues that no single development in technology or management technique promises even one order-of-magnitude improvement in software productivity, reliability or simplicity within a decade, because the hardest part of software is its conceptual essence rather than writing it down.

Objection 2

What is the difference between essential and accidental difficulty?

Brooks divided software's difficulties into essence, "the difficulties inherent in the nature of software," and accidents, "those difficulties that today attend its production but are not inherent." The essence is the conceptual construct of data, relationships, algorithms and functions. The accidents are the work of representing that construct in a programming language and on a machine.

Objection 3

What did Brooks say is the hardest part of building software?

Brooks wrote that "The hardest single part of building a software system is deciding precisely what to build." He argued that requirements can't be fully specified in advance and recommended rapid prototyping and incremental development so that people can try versions and refine what they want.

Objection 4

Do AI coding agents disprove No Silver Bullet?

Coding agents greatly reduce what Brooks called the accidental work of turning a design into code. His argument predicts what happens next: if the conceptual work already takes most of the time, faster expression alone can't give large gains, and the remaining time goes to deciding what the software should do.

Objection 5

How does Brief help with the essential difficulty of software?

Brief records product decisions with their reasons, including decisions it reads from Slack, Jira, Confluence and GitLab. Coding agents set up with Brief search recorded decisions before they start work and use check mode to flag conflicts in significant changes, and open questions can be proposed as pending decisions that name who should decide. Brief doesn't make the decisions, and it only knows the ones a team has recorded.


Previously
No. 115

Theory Building

Your codebase is what is left over from what your engineers understand. Agents only get the leftovers.