The Manifesto

Orchestrated intelligence

overautonomous generation

Humans set direction and own outcomes; AI executes. Clear ownership lines safeguard against AI-introduced vulnerabilities by incentivizing understanding and quality. This enables us to move fast and safely.

Compounding context

overclever prompts

The quality of AI output is governed by the quality of the context behind it. Context that lives in someone's head is a bottleneck; context captured, curated, and governed is an asset that compounds with every cycle. The prompt is disposable. The context is the moat that protects investment.

Verified outcomes

overgenerated output

Volume is not value, and activity is not impact. We hold ourselves to business results, not hours billed, story points burned, or lines produced. Nothing is generated and forgotten — every decision is understood, reviewed, and defensible in production.

Governance woven in

overguardrails bolted on

Faster generation demands stronger control, not weaker. Review, security, and compliance are properties of the loop itself, present from the first commit — not a gate we add once something breaks.

Whole-organization adoption

overdeveloper-only tooling

AI is a behavioral shift, not a license you hand to engineers. Giving people access is not adoption. Value shows up only when the way of working changes — across product, design, QA, operations, and the business itself.

Protect human attention.

Attention is the scarce resource now, not generation capacity. We spend it before the work — framing the problem, setting the guardrails, stating the standard — because correcting output afterward costs more than directing it up front.

Autonomy is a spectrum.

How much we delegate depends on how expensive the decision is to undo. Reversible choices go to the agent; irreversible ones stay with a person.

Explainability is table stakes.

Nobody ships what nobody can explain. Someone must be able to say how the system works, why it is safe, how it changes, and how it behaves under load.

Systematically share knowledge.

The same capacity that produces the work first produces the specifications and tests that govern it and then produces the documentation that explains it. Understanding scales with the system instead of lagging behind it, and it belongs to the organization rather than to whoever wrote the code.

Defend accuracy to win trust.

Trust is won over years and lost in seconds. A single confident wrong answer costs more than a long run of correct ones earns, so we state plainly what is established practice and what is still being tested.

Roles expand; they do not narrow.

Practitioners take on work that used to belong to other roles rather than less of their own, and team shapes change with them. Where one role ends and another begins is a decision about where judgment should sit, not a byproduct of what the tools now allow.

Commit to the layer that persists.

Standards, context, and judgment outlive every tool that serves them. We treat instruments as replaceable and keep the cost of swapping one low by design.

Re-implement discipline rather than discard it.

Code review, testing, and change control were answers to real failures, and those failures have not gone away. The mechanisms change, but the reasons behind them do not.

Measure value, not activity.

Adoption counts, hours saved, and volume generated tell you people are using the tools, not that the work succeeded. Every measure we keep is one we are prepared to act on.

Experiment and iterate; it’s cheaper than ever.

Generative tooling reduces the cost of rework, so experimentation should accelerate. Acquire certainty faster because it is quicker to validate hypotheses, acquire user feedback, and stress-test logic.