When the effort required to implement software falls, the ability to produce more functionality becomes a less convincing advantage. The harder questions remain: Which problem deserves a product? What should it leave out? Which capabilities should it reuse? How little interaction can the customer need to get a complete result?
AI makes these questions more urgent. It can help a small team explore ideas that previously required a larger engineering commitment. It can also make it easier to build the wrong thing, extend it indefinitely, and mistake an expanding application for a growing business.
My strategic proposition is a portfolio of simple products, built from interoperable capabilities and delivered through carefully designed experiences. The research behind modularity, feature fatigue, and human decision-making gives this proposition substance. The evidence on AI productivity also sets a boundary: easier implementation is a possibility to exploit and measure, rather than a universal productivity guarantee.
These six principles describe how I would build in that environment.
The manifesto
- One product. One clear job.
Complete a specific job exceptionally well, for a clearly defined audience.
- Subtraction is a competitive skill.
Remove complexity without losing value. Challenge every feature, step, and decision.
- Nintendo outside. Unix inside.
Small, interoperable, replaceable capabilities inside. An opinionated, coherent, intuitive experience outside.
- The experience is the product.
Help the customer accomplish the job, with the interaction it actually requires.
- Build more projects, not more features.
Build another focused product when a distinct purpose justifies it. Reuse interoperable capabilities across the portfolio.
- Know when not to use AI.
AI-designed, deterministic tools for predictable operations. AI-powered, flexible tools for interpretation, judgment, or adaptation. Use the simplest implementation appropriate to the job.
1. One product. One clear job.
Build capabilities that accomplish specific jobs exceptionally well. Know who the product is for, and who it isn't. A complete solution to a narrow problem beats an incomplete solution to many problems.
The word complete matters. A tool that extracts figures from an invoice but leaves the customer to identify the supplier, check the totals, and repair the export has completed an operation. It may still leave most of the customer's job unfinished. A focused product should define the result the user can actually rely on, including the exceptions that belong to that result.
Focus therefore requires a boundary around the whole job. A captioning product might take a recording through transcription, timing, correction, and a usable subtitle export. It does not automatically need a social network, a campaign planner, or a general video editor.
Research on feature fatigue helps explain why this discipline can be commercially difficult. Thompson, Hamilton, and Rust found that consumers give capability more weight before using a product, while usability becomes more important through use. Buyers can choose a richer product than they subsequently enjoy using.1
That finding is a warning about how to listen to requirements. A feature can make a demonstration more attractive while making the recurring job harder. Evaluate the product with people completing the job, including first use and recovery from mistakes. The relevant question is whether the intended customer reaches the intended result with less effort.
2. Subtraction is a competitive skill.
Adding features is becoming easier. Removing the right ones still requires judgment. The ability to remove complexity without losing value is a differentiator because it requires understanding what creates the value in the first place.
Gabrielle Adams and colleagues provide a useful explanation of why subtraction needs deliberate attention. Across eight experiments reported in Nature, participants systematically overlooked advantageous subtractive changes. Reminders to consider subtraction, opportunities to learn, and lower cognitive load made those changes more likely to be found.2
This was research on problem-solving, not a trial of AI product teams. My inference is that cheaper implementation can amplify an existing tendency: when adding is easy and visible, removing may receive too little consideration.
Product reviews should therefore challenge four things explicitly:
- Does this feature need to exist?
- Can this step disappear?
- Can this decision be eliminated?
- Is this complexity necessary for the outcome?
The aim is to remove work, rather than conceal it. Replacing five controls with an empty prompt box may leave the user responsible for specifying everything those controls used to explain. An opinionated default, automatic context retrieval, or the elimination of a redundant approval can remove more effort than a visually minimal screen.
Keep the decisions that carry meaningful consequences. Remove the ones the product can resolve dependably from context, policy, or a well-chosen default. Then measure completion, errors, and the work users still perform outside the product.
3. Nintendo outside. Unix inside.
Inside: small, interoperable, replaceable capabilities, each doing one thing exceptionally well. Outside: an opinionated, coherent, intuitive experience. The internal architecture maximizes composability. The external experience minimizes complexity.
The Nintendo reference is a design analogy. In Nintendo's account of developing the Wii Remote, the team describes simplicity, comfort, and making the controller approachable as central concerns.3 The customer encounters an experience designed around an activity, rather than a demonstration of every capability the hardware contains.
The Unix reference expresses the complementary architectural idea: focused tools become more useful when they can work together. Parnas's foundational paper on modularity supplies a more precise design test. The benefits depend on how a system is divided; modules should hide design decisions that could change, so changes do not spread unnecessarily through the system.4
A modern capability needs a clear contract: what it accepts, what it returns, how it fails, and which permissions it needs. A product should be able to replace its transcription provider or rendering engine without requiring the customer to learn a new workflow.
This does not require a separate network service for every function. A module, library, local executable, or hosted API can provide the right boundary. Deploying a distributed system introduces its own coordination and operating costs. Choose a deployment boundary when the requirements justify one.
The combination creates room for specialization on both sides. Capability builders can improve a bounded operation. Experience builders can assemble the appropriate operations into a complete job. The customer should receive the benefit of that composition without having to become the systems integrator.
4. The experience is the product.
The customer does not care how many capabilities are involved. They care about accomplishing the job. The destination is an experience layer that intelligently assembles capabilities, including those built by others.
Single-button flows are an aspiration. Sometimes no button is required: a product can prepare a routine report when the required data arrives. Sometimes deeper interaction is valuable: a reviewer may need to examine evidence, compare alternatives, and understand uncertainty before making a decision. The design challenge is knowing what interaction the job actually requires.
Counting clicks alone cannot answer that question. One button followed by an unexplained result can create more work than a short, well-structured review. Likewise, a conversational interface can be useful when intent is ambiguous, but burdensome when the user simply needs to repeat a well-defined operation.
Google's HEART framework offers a practical discipline for evaluating experience. It connects product goals to signals and metrics across happiness, engagement, adoption, retention, and task success.5 For a focused product, task success provides a useful starting point: did the person complete the job, how long did it take, and what errors or recovery work were involved?
I would also track the effort required to reach a result the customer accepts. That includes checking outputs, correcting mistakes, moving information between tools, and handling exceptions. These measures can reveal whether the experience layer has absorbed complexity or merely passed it back to the customer.
An experience advantage comes from repeated understanding of the user's context: sensible defaults, dependable handoffs, appropriate interaction, and graceful recovery. It has to survive ordinary use after the demonstration ends.
5. Build more projects, not more features.
AI changes the economics of creating narrowly focused software. Instead of continually expanding one application, build additional focused products when requirements justify a separate purpose. Reuse interoperable capabilities across them.
The strategic opportunity is a portfolio of simple products, not an accumulation of complex applications.
The qualification about purpose is essential. A new request may belong inside an existing product when it serves the same customer, context, and outcome. A separate product becomes more convincing when the job, audience, interaction, permissions, or operating requirements are materially different. That is a product decision; the mere availability of a coding agent does not settle it.
The research on AI-assisted development shows both the opportunity and the need to measure it. In a controlled experiment conducted in 2022 and published in 2023, Peng and colleagues randomly assigned 95 programmers to a JavaScript HTTP-server task with or without GitHub Copilot. Among those who completed the task, the AI-assisted group took 55.8% less time on average.6
In a different setting, METR studied 16 experienced open-source developers completing 246 issues in repositories they knew well. With early-2025 AI tools allowed, tasks took an estimated 19% longer.7 In February 2026, METR reported that later results suggested improvements but that selection effects and measurement problems made them unreliable estimates of the current effect.8
These studies do not establish that small products outperform large applications. My strategic inference is more specific: where AI reduces implementation effort, it becomes less expensive to test a separate product with a clear purpose. The investment decision still needs evidence of demand and the full cost of operating it.
A portfolio also has an overhead. Separate products can multiply onboarding, billing, support, and maintenance. Shared identity, interoperable data, and reusable capabilities should keep those costs under control. Close or combine products that no longer justify their separate existence. Subtraction applies to the portfolio as well as to each application.
6. Know when not to use AI.
Distinguish between two kinds of tools:
- AI-designed, deterministic tools: well-defined operations with predictable execution.
- AI-powered, flexible tools: tasks requiring interpretation, judgment, or adaptation.
Both belong in the new software world. The objective is to use the simplest implementation appropriate to the job.
AI used during development and AI used during execution are separate choices. An AI coding assistant can help build a subtitle timing converter, a calculator, or a document renderer that requires no model call when a customer uses it. The generated implementation still needs engineering review and verification; its development history does not guarantee correctness.
When the input, rules, and expected output are well defined, conventional code can provide a direct, testable implementation. When the task involves interpreting a request, extracting meaning from varied documents, or adapting a plan to incomplete information, a model may supply a useful capability.
Anthropic's engineering guidance makes a related architectural distinction: predefined workflows suit well-defined paths, while agents let a model choose its process and tools dynamically. It recommends starting with the simplest approach and increasing complexity when the task warrants the additional cost and latency.9 A fixed workflow can still contain model calls, so predictable orchestration should not be confused with deterministic outputs.
Orchestration is itself a capability, not a separate category. If the sequence and routing rules are known, code can orchestrate them. If selecting the next action requires interpretation or adaptation, a model can perform that part. The same experience may combine both.
For example, a briefing product might use AI to interpret a question and summarize relevant material, while ordinary code retrieves authorized records, validates dates, calculates totals, and renders the final document. Each part earns its place by doing the job appropriately.
For low-stakes chains, an AI judge can provide a useful quality signal when calibrated against representative examples. For high-stakes chains, I would combine subject-matter experts with AI as a second opinion, alongside explicit checks wherever the requirements allow them. Disagreements and exceptions should become audit evidence. An AI judge is not an independent guarantee of correctness, and agreement between models is insufficient evidence to reduce oversight.
That evidence also helps determine when a chain can move toward lower-risk, more predictable operation. Repeatability, well-characterized failures, and stable acceptance criteria can reveal opportunities to replace open-ended judgment with a narrower implementation.
What makes this a moat
A simple product can be copied. A tidy interface, a small codebase, or access to a model does not by itself create a durable advantage.
The stronger claim is about a capability developed through repeated practice: selecting a valuable job, understanding its context, excluding distractions, composing dependable parts, and improving the experience from evidence of actual use. Reusable capabilities can make the next product easier to deliver. Trusted experiences can give customers a reason to return. Neither outcome follows automatically from creating more projects.
The six principles work together. A clear job gives subtraction a purpose. Modular capabilities make reuse practical. A coherent experience turns the composition into something a customer can use. A portfolio creates room for distinct purposes, while disciplined implementation keeps each product as simple as its job allows.
That is where I would place the strategic bet: a portfolio of focused products that complete valuable jobs, built on capabilities that can be reused and replaced.
References and evidence
The research below supports particular mechanisms and observations. The portfolio strategy and the six-principle synthesis are my proposals; no cited study tests the manifesto as a whole. Figures 1 and 3 are original conceptual illustrations. Figure 2 redraws reported results rather than reproducing a published chart. Research reviewed on 29 October 2026.
-
Debora Viana Thompson, Rebecca W. Hamilton, and Roland T. Rust (2005). Feature Fatigue: When Product Capabilities Become Too Much of a Good Thing. Journal of Marketing Research, 42(4), 431–442. The study concerns consumer capability and usability tradeoffs, rather than contemporary AI software. See also the University of Maryland's account of the research. ↩
-
Gabrielle S. Adams, Benjamin A. Converse, Andrew H. Hales, and Leidy E. Klotz (2021). People systematically overlook subtractive changes. Nature, 592, 258–261. Abstract and bibliographic record. Eight experiments establish a tendency to overlook subtraction under the tested conditions, not a measured return on removing software features. ↩
-
Nintendo. Iwata Asks Wii Remote — Taking Control Back to the Drawing Board. First-party design history describing simplicity, comfort, and an approachable controller. Used as a design analogy, not as causal evidence for a software business model. ↩
-
D. L. Parnas (1972). On the criteria to be used in decomposing systems into modules. Communications of the ACM, 15(12), 1053–1058. A foundational argument about decomposition and information hiding; it does not imply that modules must be separately deployed services. ↩
-
Kerry Rodden, Hilary Hutchinson, and Xin Fu (2010). Measuring the User Experience on a Large Scale User-Centered Metrics for Web Applications. CHI 2010. Introduces HEART and the mapping of product goals to signals and metrics. ↩
-
Sida Peng, Eirini Kalliamvakou, Peter Cihon, and Mert Demirer (2023). The Impact of AI on Developer Productivity Evidence from GitHub Copilot. Experiment conducted May–June 2022; 95 programmers randomized. Among task completers, mean times were 71.17 minutes with Copilot and 160.89 without, reported as a 55.8% reduction. The paper does not estimate full software lifecycle costs or establish a general code-quality improvement. ↩
-
Joel Becker, Nate Rush, Beth Barnes, and David Rein (2025). Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity. Randomized trial covering 16 developers and 246 repository issues, using February–June 2025 tools. Estimated task-time increase: 19%, with a 95% interval of 2–39%. ↩
-
Joel Becker, Nate Rush, Tom Cunningham, David Rein, and Khalid Mahamud (24 February 2026). We are Changing our Developer Productivity Experiment Design. Later observations suggest improvement, but participant and task selection, changed compensation, and concurrent-agent time measurement limit interpretation. The authors describe the later data as an unreliable signal of the current productivity effect. ↩
-
Erik Schluntz and Barry Zhang, Anthropic (19 December 2024). Building effective agents. Practitioner guidance on composable patterns, workflows, agents, and complexity tradeoffs. This supports an architectural principle; it is not a controlled comparison proving a universal best implementation. ↩