Chris Marcus

Most companies using AI in engineering today are at the copilot stage - developers get autocomplete suggestions and write code a bit faster. That's a 20-30% productivity gain at best, and it still requires the same headcount.

Agentic development is the next step. Instead of AI assisting a human developer, AI agents are the developers. They read requirements, write code, create tests, open pull requests, and review each other's work - autonomously. A human architect sets direction, reviews decisions, and approves merges. The AI does the implementation.

Think of it as the difference between a GPS that suggests turns (copilot) and a self-driving car that takes you to the destination while you decide where to go (agentic). The human role shifts from writing code to directing outcomes.

The ROI Case

A feature that takes a team of five engineers a quarter to build is a quarter of that team's capacity spent on one thing - before management overhead, coordination costs, and the delays that come with hiring.

This is not theoretical. I built a full production insurance platform - a separate database for every agency, AI analysis pipelines, compliance engine, developer API - using this model. It is described below, and it is for sale.

That platform is now offered for sale outright, source code included, to a large agency or an agency network. It was built to be handed over; the case study below is what it took to build.

Independent insurance agencies generate billions in premiums but run on legacy management systems built decades ago. I built agentCanvas.ai - an AI-native insurance platform, with a separate database for every agency, that ingests real insurance policy data via Canopy Connect and an inbound API an agency's own systems can post to, runs it through configurable AI analysis pipelines, and delivers actionable intelligence to producers. Full producer workspace, consumer-facing data collection, developer API, multi-agency isolation - a project that would normally need a team of 5-8, designed, built, tested, and deployed by one person. That was possible because the operating model came first, not because the work was small: rebuilding the same scope, estimated module by module against the code that exists, comes to 131 engineer-months.

Before writing a line of product code, I spent 3-4 months designing an AI-native engineering operating model: prompting standards, repo structure conventions, task decomposition workflows, and QA processes that enabled reliable, repeatable AI-agent output at production quality. This was not autocomplete - it was architecting workflows around AI agents to ship production software at a pace that would normally require a full engineering team.

The platform runs end to end on Microsoft Azure - Container Apps, Cosmos DB for MongoDB, Key Vault with Managed Identity, Blob Storage, Cache for Redis, and AI Search - with every release built and published by an automated pipeline. The AI layer runs on Anthropic, and only Anthropic: the vendor's own toolkit is confined to two files behind an internal interface, with a build check that fails if it spreads anywhere else. Which model serves which tier of work is fixed in configuration rather than chosen at run time, so changing supplier later is a contained job rather than a rebuild. Analysis runs as each policy record lands, and every call records what it used and what it cost, per agency.

Next.js 16, React 19, TypeScript, Azure Container Apps, Azure Cosmos DB for MongoDB (vCore), Azure Key Vault with Managed Identity, Azure Blob Storage, Azure Cache for Redis, Azure AI Search, Azure Container Registry, Anthropic Claude.

The Agentic Delivery Pipeline Behind It

After a year of building with AI coding agents, I kept hitting the same wall. I'd write requirements, then spend half my time orchestrating the agents through implementation. Context-switching between "what should we build" and "let me check what the agent just did" was eating the productivity gains. So I removed myself from the loop.

The pipeline now: I write a requirements doc. Claude breaks it into stories in Linear via MCP. Each story becomes a GitHub Issue. When labeled agent:ready, a GitHub Actions workflow spins up a headless dev agent that reads the issue, implements the feature, writes tests, opens a PR, and shuts down. Review agents pick up the PRs automatically, validate them, and shut down too.

Four human touchpoints: feed requirements, review the plan, check tasks, read PRs - not diffs, but the agent's decision narrative. Every agent decision, every line of code, every review comment is captured in the PR history - a complete audit trail of what the AI did and why, with human approval at the PR level before anything hits main. In regulated industries, that's not a nice-to-have - it's what gets Legal to sign off.

This isn't a coding pattern. It's a work pattern. The result is a proven playbook for AI-native development at production quality - one I bring to every engagement.

View the open-source Headless Claude Automation Template

Through AIDX Consulting, I embed with companies as a fractional CTO or technical advisor. The typical engagement: a company knows AI is critical to their roadmap but lacks the in-house expertise to move from experiment to production - especially when regulators are watching. I come in, set the AI and product strategy, stand up the agentic development capability, and start shipping.

Engagements span the full stack of AI leadership: defining AI strategy and roadmaps, building production ML systems (not just LLM wrappers - classical ML like the XGBoost ensemble model for carrier-product fit ranking I recently authored), leading core-platform rewrites, and training existing engineering teams to work with autonomous AI agents.