How I Think About AI in Software Delivery

The Context Revolution

We've been optimizing the wrong thing.

For years, we architected systems around how we think - classes, layers, patterns, frameworks. Then frontier models matured, and the rules changed permanently. In 2026 the model itself is table stakes: Claude Fable 5.1, Opus 5.5 and Sonnet 5.5, OpenAI GPT-6, and even the small, fast tiers like Claude Haiku 5.5 and Gemini 3.8 Flash are all remarkable straight out of the box, and the release cadence now measures in weeks rather than quarters. The fastest-moving teams aren't winning by writing better prompts, or even by picking the best model. They're winning by recognizing a deeper shift: AI operates on context, not abstraction. While competitors were prompt-hacking, winners were architecting context as a first-class concern. They standardized it (AGENTS.md, CLAUDE.md, CONTEXT.md, SCHEMA.md). They versioned it. They made it infrastructure. Your competitive advantage isn't your code anymore, and it isn't your model - it's how well you feed context to the models that generate your code.

Markdown is the Substrate

Markdown has become the de facto standard for AI-native organizations. It's token-efficient, easily parsed, and both human- and machine-readable. Strategic plans, architecture decisions, and product roadmaps all belong in version-controlled .md files. Markdown carries the human-readable context; JSONL (a site I own) carries the machine-readable side - training sets, eval logs, and agent traces. Together they are the substrate for building with AI.

Context as a Product

Requirements are now code, written in a language understood by both humans and AI agents. This is the essence of agentic development: designing with AI, not just prompting it. I call this the SP(IDE)R approach, turning ideas into structured, versioned artifacts that evolve with your codebase, not in a stale wiki.

AI Codes, Engineers Architect

Generative AI excels at coding tasks, but software engineering is about building resilient, scalable systems. AI can write a function, but an engineer must architect the system. My approach leverages AI for the former, freeing up engineers to focus on the latter.

Leverage, Not Replacement

Senior engineers architect context. AI multiplies their expertise, automating repetitive tasks and scaling strategic work. This isn't about replacing engineers; it's about leveraging their experience to solve bigger problems.

MCP: The Protocol Layer for Agentic Infrastructure

The Model Context Protocol (MCP) and Agent2Agent (A2A) protocols are the connective tissue of production agentic systems. MCP lets AI agents reach into codebases, CI/CD pipelines, observability tools, and internal APIs - giving them real operational context, not just document summaries. When context is infrastructure and MCP is the protocol, AI agents stop being assistants and start being contributors with measurable SLOs.

The Intent Imperative

Context without intent is like a loaded weapon with no target.

Enterprise AI is undergoing its next major shift. For years, the competitive edge lived in prompt engineering, then context engineering - feeding the right information to the right model at the right time. That era is ending. The organizations pulling ahead now are investing in intent engineering (a site I own): explicitly embedding goals, values, and trade-offs directly into autonomous agents before they act.

The boldest truth in enterprise AI today is this: an organization with a mediocre model and strong intent infrastructure will consistently outperform a company running a frontier model without alignment. Model capability is table stakes. Intent is the differentiator.

The Alignment Warning

Deploying autonomous agents without strict, goal-oriented alignment isn't just a technical risk - it's a business liability. Agents operating on context alone know what to do but have no principled basis for deciding whether they should. Context tells the agent what's true. Intent tells it what to value. Without intent, you've built a powerful system pointed at nothing in particular.

Speed Without Wisdom

AI can automate tasks with a flawlessness and speed that humans cannot match. That's the promise. The warning is equally real: the moment you remove the human context needed to intuitively navigate customer feelings, relationships, and organizational trust - speed becomes destruction. Automation that loses the human thread doesn't just fail to delight customers. It actively erodes the trust that took years to build.

Intent as Infrastructure

The teams I build treat intent the same way we treat context: as versioned, governed infrastructure. Before an agent ships, it gets an intent spec - a short, executable contract that names the outcome it owes the business and the boundaries it cannot cross: objective, success criteria, constraints, tool permissions, escalation triggers, stop rules, and a named owner. It lives next to the agent in source control, gets reviewed in PRs, and is enforced in CI through evals. If you cannot write the spec, the agent is not ready for production.

An Intent Spec You Can Copy

This is the shape I start every agent with. Copy it into intent-spec.md next to the agent, fill in every section, and review it in the same pull request as the agent itself. A section you cannot fill in is the reason the agent is not ready yet.

# intent-spec.md - [agent name]

Owner: [one named person who answers for this agent]
Version: [x.y], reviewed in the PR that changes the agent

## Objective
The one outcome this agent owes the business, in a single sentence.

## Success criteria
- Checks an eval can run and score pass or fail - not impressions.

## Constraints
- What it must never do: data it may not read, systems it may not change,
  cost and time ceilings per run.

## Tool permissions
- Allowed: [each tool and the narrowest scope it needs]
- Everything else is denied.

## Escalation triggers
- When it stops and hands the decision to a person: low confidence,
  an irreversible action, a policy edge case, verifier disagreement.

## Stop rules
- When it halts outright: budget spent, [n] failed attempts,
  a constraint about to be crossed.

## Evals (the CI gate)
- The suite that proves the objective is met. It runs on every change
  to the agent, its prompts or its model, and a red run blocks the merge.

The 2026 Reality: Agents Are Outrunning Governance

The next failure mode isn't a bad prompt - it's thousands of autonomous workflows with unclear ownership, loose permissions, and no shared operating model. As of mid-2026 the spending has outrun the evidence: fewer than a third of enterprise decision-makers can name a specific financial outcome from their AI investment, and Forrester has enterprises deferring roughly a quarter of planned AI spend into 2027. Almost none of that is because the model wasn't capable. The fix is operational: agent inventories and owners, approval gates for irreversible actions (schema migrations, prod deploys, customer comms), and FinOps that tracks cost-per-outcome instead of burying token spend in the cloud bill. And the evals that gate it all measure whether an agent achieved its declared intent - not how it scores on a public benchmark. A model that tops the leaderboard but fails its intent evals is not shipping.

The AI Bottleneck Shift

You accelerated coding. Now everything else is the constraint.

Teams adopting AI are experiencing a textbook example of the Theory of Constraints playing out in real time across the modern software development lifecycle. By applying AI to the coding phase, you have dramatically widened the pipe in the middle of your value stream. Because developers can write, refactor, and scaffold code faster than ever, the constraints have naturally shifted to the stages immediately before and after coding.

Upstream: The Backlog Starvation

This is becoming the most common complaint among product and engineering teams adopting AI.

• The Beast Needs Feeding. AI-accelerated developers consume user stories at an unprecedented rate. Product Managers and Business Analysts simply cannot write, refine, and size requirements fast enough to keep up using traditional methods.
• Prompt Precision. AI coding tools require highly specific, well-defined parameters to produce good results. A vaguely written user story that a senior developer could previously "figure out" through tribal knowledge will cause an AI tool to hallucinate or generate rework. Grooming now requires a higher level of technical specificity, taking more time per ticket.

Downstream: The Verification Traffic Jam

The bottleneck shifting to QA and release processes is the direct result of higher code volume hitting static pipelines. DORA's 2026 research calls it the verification tax: the review and validation cost that cheap authoring shifts onto humans, and the reason the numbers look worse before they look better.

• Review Fatigue. Pull requests are becoming larger and more frequent. Human reviewers are struggling to keep up with the volume of code generated by AI, leading to longer lead times in the review stage. Where the fix is to let an agent review the agent, nobody has signed for the change.
• QA Overload. If your QA team is still relying heavily on manual testing or if your automated test suites are slow, they will instantly become the new choke point. They are receiving more features to test in a shorter amount of time. The way out is to hand them the generator, not the backlog: AI did not replace QA, it deleted the typing.
• Infrastructure Limits. Even automated CI/CD pipelines can become bottlenecked if they were not scaled to handle a massive increase in commit frequency and parallel test executions.

How I Fix This

This is the exact problem I solve. Most teams stop at accelerating code generation. I treat the entire value stream as the system to optimize.

• I Shift AI Upstream. I equip Product Owners and Business Analysts with AI tools and structured workflows to draft user stories, generate acceptance criteria, and map out edge cases at the speed your developers now consume them. Context-first requirements in versioned .md files replace vague tickets that cause AI rework.
• I Shift AI Downstream. I deploy AI-assisted test generation and agentic code-review systems that read pull requests and generate the matching unit and integration tests with full codebase context and audit trails. On my last team that lifted test coverage from under 10% to 40% with no dedicated QA team and added 23% PR throughput - unblocking QA instead of flooding it.
• I Restructure Team Ratios. The historical ratio of Product to Engineering to QA no longer applies. I help leaders right-size their organizations, shifting newly freed developer capacity into testing infrastructure, QA automation, and upstream requirements engineering where the constraints now live.
• I Build the Measurement System. Deploy frequency, PR cycle time, MTTR, code coverage, and custom value-stream analytics that make bottleneck shifts visible in real time - so leadership can respond before constraints become crises.
• I Make Review More Expensive, Not Less. The instinct when the queue backs up is to approve faster and batch more. That generates technical debt at machine speed and calls it velocity. I do the opposite: stricter gates rather than looser ones, the architecture conversation moved earlier than the pull request, and QA converted from a downstream consumer into a parallel producer of coverage. Full write-up in Where the Bottleneck Moved.

AI doesn't just make developers faster. The real win is accelerating the entire value stream so no single phase becomes the bottleneck. That's what I do.

The original observation, with the four constraints that appeared the week the coding bottleneck dissolved, is in We Did Not Remove the Bottleneck. We Moved It. The operating model that closes the gap - ticket contracts, plan approval, risk-tiered review, agents run as services - is in An Operating Model, Not a Tooling Purchase.

Execution Principles

Strategy without execution is hallucination.

• Stop duct-taping AI onto old workflows. Real value comes from reimagining the process from the ground up.
• AI must prove its value, not just promise it. I build systems that earn the trust of skeptical development teams by delivering tangible results.
• Embed with purpose, don't retrofit with hope. AI is a foundational element of the architecture, not a feature bolted on later.
• The goal is acceleration, not just automation. I put frontier models to work as first-class pipeline stages - Claude Opus 5.5 and Sonnet 5.5, OpenAI GPT-6 and Codex, GitHub Copilot, and Gemini 3.8 Flash - creating clarity and flow so engineers solve bigger problems instead of typing boilerplate.
• AI that ships, not AI theater. On my last team: 5x deploy frequency, 23% PR throughput gain, test coverage lifted from under 10% to 40% with no dedicated QA team, and new-engineer onboarding cut 70%. If it cannot be measured, it is not in the plan.
• Multi-model, never single-vendor. I run a deliberate multi-model strategy so teams build fluency across platforms - and so one vendor's price hike or bad release never holds the roadmap hostage.

From Idea to Shipping: The Complete AI Journey

Whether it's a new product idea or a new feature, AI accelerates every step from concept to customer.

1. Ideation & Validation

Start with market intelligence, not assumptions. AI analyzes market trends, competitor features, customer signals, and technical feasibility to validate ideas before engineering investment. Transform "we should build X" into data-driven "we should build X because Y."

2. Requirements & Architecture

Capture context in .md files that both humans and AI understand. Competitive analysis, user research, and architectural decisions become versioned, living documents. Requirements evolve with the codebase, not in disconnected wikis.

3. Rapid Prototyping & MLP

AI agents transform structured requirements into working prototypes. From specs to deployable MLPs, context drives wireframes, user stories, API designs, and initial commits. Validate faster, fail cheaper.

4. Development & Testing

Frontier models - Claude Opus 5.5 and OpenAI GPT-6, with Codex and Copilot in the IDE - pair with engineers through the entire development cycle. Code generation, refactoring, test creation, and security scanning all draw on the same context repository. Your team ships faster while maintaining quality.

5. Deployment & Launch

AI-enhanced CI/CD pipelines explain failures, suggest fixes, and optimize deployments. Agentic AI systems handle rollouts, monitoring, and incident response. Launch with confidence, scale with intelligence.

6. Post-Launch Optimization

Continuous feedback loops powered by AI. User behavior, feature usage, error patterns, and support tickets flow back into improvement plans. The cycle repeats: ideas -> validation -> build -> ship -> learn -> optimize.

This isn't linear. It's iterative. AI makes each cycle faster, smarter, and more reliable than the last.

The Infrastructure Gap

Your laptop wasn't built for modern development.

AI inference, LLMs, Docker containers, Kubernetes, and resource-intensive builds are pushing local machines past their limits. The laptop designed for email and documents is now expected to run GPU-accelerated models, multiple databases, and complex CI/CD pipelines - and stay responsive while doing it. As I build internal developer platforms, where the dev environment itself runs becomes a real architectural decision.

• Cloud Development Environments. CDEs like Coder, Ona (formerly Gitpod), and GitHub Codespaces move compute-intensive work to remote infrastructure on Terraform templates and Kubernetes pods. VS Code Remote SSH and JetBrains Gateway keep the IDE local while builds, tests, and AI inference run in scalable cloud workspaces.
• Making the right call. CDEs aren't for everyone. The decision comes down to your workloads, your team, and your compliance posture - including HITRUST and SOC 2 - weighed honestly against self-hosted vs managed trade-offs and DevContainers/infrastructure-as-code.

I dig into this in depth - unbiased analysis of CDEs and developer-environment infrastructure, not vendor hype - at InfraGap (a site I own).