What we learn by building

A wrapper is not automatically a bad business, but you should price it as one. How we separate real AI from a thin layer during due diligence.

Seats are 19 to 40 dollars, tokens can be ten times that. The real 2026 budget for coding agents at team scale, and an ROI frame that survives scrutiny.

What AI due diligence adds for private equity: eval practice, data loops, margin exposure to model pricing, and defensibility a generalist read misses.

How we run the CTO interview in due diligence: preparation, questions that open engineers up, and the signals in how a leader talks about failures.

Claude Code, Cursor and Copilot are different tools, not rivals. What each does best, what they cost in 2026, and how we choose per team and policy.

Fine-tuning vs RAG vs prompting as an escalation ladder: what each one changes, what each costs to maintain, and why fine-tuning is rarely the first move.

Realistic AI customer support ROI: resolution rates to plan on, the deflection trap, three patterns that pay, and the escalation design that protects CSAT.

How to reduce LLM costs in production: model routing, caching, context discipline and batching, and why unit cost must be designed before you scale.

A maturity ladder for AI coding: suggestions, chat, single-task agents, delegated workflows, parallel orchestration, and what moves a team up each level.

Running multiple coding agents in parallel: worktrees, task isolation and review queues, what the pattern demands from your process, where it breaks.

Where EU AI Act enforcement stands in 2026, which targets carry real exposure, and the questions investors should add to technical due diligence.

A postmortem pattern for incidents involving AI-written code: blameless analysis, the gate that failed, and fixes that work better than banning the tool.

Open source license due diligence without the theater: the findings that are actually deal-relevant, upstream license changes, and AI-generated code provenance.

Legacy code looks like the worst place for coding agents. It is often the best: characterization tests, documentation archaeology, safe migrations.

How to verify an AI startup’s performance claims inside a deal window: eval sets, held-out tests, production logs, and reading the demo choreography.

Does AI-generated code create technical debt? The GitClear and CodeRabbit numbers say yes, when unmanaged. The guardrails that keep speed from souring.

Most AI proofs of concept never ship because they prove the demo, not the workflow. What production requires, and how to scope a POC that can graduate.

The AI coding adoption gap is workflow knowledge stuck in two heads, not a talent problem, and it closes with skills, conventions and champions.

AI writes code faster than your team reviews it. Why rubber-stamping and reviewer fatigue follow, and the redesign that gets throughput back safely.

Which process to automate with AI first: four criteria that predict success, why impressive demos make bad first projects, and a scoring shortcut.

Honest cost ranges for custom AI by system type, from a RAG assistant to a multi-agent system, what drives the price, and the running costs after launch.

A failing test is the only feedback a coding agent reliably respects. How TDD makes delegation safe, who writes the test, and where the leash ends.

Copilot acceptance rate tells you code was inserted, not that delivery improved. The metrics that track real AI impact: cycle time, review, defects.

The baseline metrics to capture before AI adoption: cycle time, review load and defect rate per team, from tools you already run, in a single week.

What belongs in CLAUDE.md and AGENTS.md, what does not, and how a bloated context file quietly degrades every agent session on your codebase.

Self-hosted LLM vs API, decided honestly: what control really buys, what it costs in GPUs and people, who genuinely needs it, and the middle options.

ChatGPT Enterprise vs custom AI is the wrong fight: what off-the-shelf assistants do well, where they plateau, and when each is the right spend.

What LLM observability looks like in production: tracing, cost per request, quality signals, drift and alerting. Why we refuse to ship AI without it.

How to measure AI coding productivity with metrics that hold up: cycle time, review load and defect rate against a baseline. And what to ignore.

Senior engineers skeptical of AI coding are reading the risks correctly. Why delegation multiplies their kind of work, and how their standards scale.

How due diligence changes when the codebase is AI-generated: comprehension debt, test reality, and the question that matters, can anyone debug it.

Invoices, claims, contracts and KYC: why document processing is the highest ROI first AI project, and the pipeline design that survives production.

Why test-writing is the ideal first task to hand a coding agent: verifiable output, bounded blast radius, real payoff. And how to keep the tests honest.

Technical debt is a number: cost to fix, cost to carry, cost to the roadmap. How to measure it in due diligence and reflect it in the deal price.

What RAG is in plain business terms: why a model needs your documents, what retrieval fixes, what it does not, and when it is the right architecture.

The CI guardrails that make AI-generated code safe to merge: test gates, static analysis, security scans and review rules that cannot be skipped.

Free-form prompting produces free-form quality. Why teams need shared conventions for framing agent tasks, versioned in the repo like linter rules.

Five days to prepare a codebase for AI agents: context files, a fast test command, seed skills, permission config and a task template that sticks.

Which LLM for enterprise work: why the frontier gap is small and unstable, why prices moved faster than quality, and why switching cheaply beats picking right.

How production AI systems control wrong answers: retrieval with citations, constrained outputs, review where stakes are high, and refusal by design.

Redesigning the development workflow around coding agents: tickets as executable tasks, review tiers, CI guardrails, and the touchpoints that stay human.

How we audit training data rights in due diligence: provenance, what contracts allow, GDPR exposure, current litigation, and what clean looks like.

How to assess key person risk in a startup acquisition: map who can rebuild each system, why AI concentrates knowledge, and how retention terms follow.

Veracode found 45 percent of AI-generated code introduces an OWASP Top 10 flaw, and bigger models do not help. The pipeline that actually does.

The six-area checklist we use to audit AI companies for funds: production reality, error handling, evals, unit economics, data rights, team risk.

The rollout playbook for AI coding tools: a baseline week, a pilot squad on real backlog, measured deltas, then champions. Licenses alone change nothing.

How we assess OpenAI dependency risk in AI deals: the four real exposures, what a working abstraction layer looks like, and when dependency is rational.

Where RAG assistants actually go wrong: chunking, retrieval, stale documents, prompt assembly and missing evals, in the order we check them.

How to test an AI startup’s gross margins in diligence: the full cost of a request, sensitivity to model prices, and what to ask for in the data room.

Bans produce shadow AI. The one-page AI coding policy that works: approved tools, data boundaries, review rules that scale with risk, honest attribution.

How to evaluate AI agent startups in diligence: task completion rates, blast radius of errors, guardrails, cost per completed task, and liability.

Chatting with a coding agent caps you at your own reading speed. Delegation is the jump most teams have not made, and it is a learnable skill.

LLM structured output reliability in production: schema constraints, validation rules, retries, confidence routing and human review, measured per field.

Most problems need one good agent, not twelve. The signals that justify a multi-agent system, what a real one looks like, and the costs the diagram hides.

The GDPR gaps we find in SaaS deals: missing data maps, weak processor terms, residency claims the infrastructure contradicts, deletion that does not delete.

What AI due diligence covers, how it differs from classic tech DD, what the report contains, and the deal stages where funds commission one.

Which technical due diligence red flags change deals, which are cosmetic, and how to decide between renegotiating the price and walking away.

How to give an AI agent access to your systems safely: blast radius analysis, least privilege, action allowlists, approval gates and audit trails.

What an eval set is, why testing LLM outputs by hand fails at the second prompt change, and how much evaluation a production business system needs.

MIT found 95 percent of GenAI pilots show no return, RAND puts AI failure at twice the IT rate. The causes are organizational and the survivors share a pattern.

Building an internal AI assistant on company knowledge: permissions, citations, freshness and adoption, and why the SharePoint chatbot disappoints.

How to measure AI ROI defensibly: baseline first, the metrics that hold up, the costs everyone forgets, and why most reported ROI numbers are soft.

How we evaluate AI moat claims in due diligence: the data loops, workflow depth and switching costs that survive model commoditization, and what does not.

What AI coding assistants do with your code: training and retention policies by vendor and tier, plus the controls to set before rolling out agents.

Agent skills are versioned instructions a coding agent loads for recurring tasks. What they are, which ones pay off first, and how to build a library.

Data readiness for AI is a per-workflow question, not a company-wide prerequisite. What each use case really needs, and what can stay messy.

Why one AI champion per engineering squad beats a central AI team: how to pick them, what they own, and the protected time budget that makes it stick.

How to scope an AI project: one workflow, one metric, one owner, and the smallest system that proves value on real data. With the anti-patterns to avoid.