Every major paradigm shift goes through a skeuomorphic phase — cars were called “horseless carriages,” early websites looked like printed pages, and now we’re building AI systems that mimic the way humans already work.
The Skeuomorphic Phase
People default to bolting AI onto existing workflows because it’s the path of least organisational resistance. If you attach AI to an existing process, you don’t have to rethink org structure, roles, approval chains, or success metrics. You just make the existing thing faster or cheaper. CTOs especially are under pressure to show ROI quickly, and “we automated step 3” is an easier story to tell the board than “we redesigned everything from first principles.”
But human workflows evolved around human constraints — limited memory, slow reading speed, 8-hour workdays, the need for consensus meetings, sequential attention. AI doesn’t share those constraints. Having an AI “draft an email, then someone reviews it, then someone approves it” is preserving a pipeline that only existed because humans are slow at drafting. The real question is whether that pipeline needs to exist at all.
What AI-First Actually Means
The essential question is: “What would this process look like if no human had ever done it before and you were designing it AI-first?”
The human workflow we’re stuck on: spec, design, break into tasks, assign to devs, code, PR, review, QA, deploy, monitor. This exists because humans need to decompose problems, communicate intent to each other, catch each other’s mistakes, and work sequentially on shared code.
An AI-first approach might look radically different:
Start from intent, not spec. Instead of translating a business need into a document that gets translated into tickets that get translated into code — you express the outcome. “Users should be able to do X, and it should handle Y edge cases.” The entire spec-to-code pipeline collapses because the translation layers existed to bridge human communication gaps.
Generate and evaluate, don’t build and test. Instead of writing code then testing it, an AI-native process might generate hundreds of candidate implementations simultaneously, each taking a slightly different architectural approach, then evaluate them all against the intent — performance, security, correctness, maintainability — and surface the best candidates. It’s closer to evolution than engineering.
Continuous verification instead of QA phases. There’s no reason to have a separate “testing stage.” Every state of the system can be perpetually verified against its intent. The distinction between “writing code” and “testing code” is a human attention bottleneck, not a natural boundary.
The codebase might not even look like code as we know it. Code is a human-readable representation of logic. If AI is both the writer and the maintainer, the optimal representation might be something entirely different — a learned model, a constraint graph, a formal specification that gets compiled to whatever runtime is needed. “Source code” as we know it is a human interface.
Files, PRs, and branches don’t disappear — they shift form. A single intelligence holding the whole system in context doesn’t “merge” two people’s work, but it still checkpoints, drafts, and promotes changes. Versioning becomes more like checkpoints on a continuous optimisation process than discrete human contributions being stitched together. The concepts persist; the human coordination overhead doesn’t.
Where Humans Still Matter
- Defining intent and values — “what should this do and what tradeoffs are acceptable”
- Judging subjective quality — “does this feel right”
- Accountability decisions — “who’s responsible when this breaks”
- Ethical guardrails — “should we build this at all”
The uncomfortable implication is that most of what software engineering is today — the sprints, the standups, the code reviews, the architecture discussions — exists to coordinate limited human brains. Remove that constraint and you’re left with something that looks less like engineering and more like gardening: you set the conditions, express what you want to grow, and prune what doesn’t work.
The complexity doesn’t disappear. It moves up. Instead of managing implementation details, you’re managing intent, constraints, and tradeoffs at a higher level of abstraction. The bet is that this is a more productive place for human attention.
From Factory to Organism
Linear is itself a human constraint. We think in sequences because we can only hold one thread at a time. An AI-native process would look more like a living system — a biological organism rather than a factory.
A factory has stages: raw material, assembly, quality check, shipping. That’s the current software pipeline. But a living organism doesn’t work in stages. It grows, adapts, repairs, and evolves all at once. Every cell is simultaneously building, sensing, and responding.
What that might actually look like: the software is always running, always being reshaped, always sensing its environment. A user struggles with something — the system feels that friction in real time — candidate adaptations start emerging — the ones that reduce friction survive — the ones that introduce new problems get reabsorbed. No one filed a ticket. No one scheduled a sprint. The organism responded to stimulus.
Multiple timescales happen simultaneously: fast micro-adjustments (tweaking responses, healing errors), medium structural changes (new capabilities emerging, old ones atrophying), and slow architectural shifts driven by long-term patterns.
The human role becomes something like a shepherd of intent — not directing the process, but maintaining the pressures and constraints that keep the system evolving in the right direction. “We want it to be fast, fair, and private” becomes a kind of gravitational field the system grows within.
If the system is organic, the next question is how you observe it — not through logs and dashboards, but through the ambiguity in its behaviour: where it has clarity, where it’s still deciding, where it’s stuck. And if you want to actually build one, you need a framework where intent is computable, gaps are detectable, and evolution happens safely within bounds.
Current: “AI writes the PR and another AI reviews it.” That’s the horseless carriage version. The car version hasn’t been built yet.