Hack40Insights

AI Speeds Up Code. Not Automatically the Company.

Deploying AI function by function, episode 1: software development. Turning individual acceleration into a collective, measured and sustainable result.

AI Speeds Up Code. Not Automatically the Company.
In this article
  1. Speeding up a task does not speed up the whole chain
  2. Control has to be built into execution
  3. Four weeks to understand, not to replace everything
  4. Add AI, modernize or change solutions?
  5. The bill does not stop at tokens
  6. Six questions to choose a real team test

The developer can finish faster. The feature still waits for a review, a trade-off or an integration. That gap is where the value of AI is won or lost.

Giving teams a powerful assistant is not enough. You have to organize what goes into the tool, what it is allowed to execute, what validates its work and what actually reaches the user. The point is not to slow AI down. It is to make its speed useful.

First episode of a series: deploying AI function by function. We start with software development, the most widespread case in 2026.

B2B startup · drive adoption

An API that responds is not enough. Support the first uses, measure their impact and feed recurring blockers back into the product.

Corporate · prove the value

Beyond licenses and pilots: measure the collective result, at comparable quality.

What the data says

Speeding up a task does not speed up the whole chain

The first finding is massive. The second, much less so.

87%

say they ship faster

28%

report clearly less day-to-day friction

49%

spend at least 4 hours a week checking or fixing AI output

Atlassian, State of Developer Experience 2026. Self-reported results.

AI helps most where work can be tested. Code is something you can check; collective work is made of dependencies, disagreements and decisions.

AI rated useful or very useful, by activity

Implementation74.6%
Debugging, refactoring72.6%
Architecture exploration59.1%
Communication35.0%

Stack Overflow, Developer Survey 2026: 12,734 responses. Perceived usefulness, not time saved.

A longitudinal study published in November 2026 makes the point:

×2

merged pull requests per engineer, ten months after AI became the norm

… and ×2 as well for PRs handled by each reviewer. He et al., November 2026: 802 developers.

The checkpoint becomes the new bottleneck. Track waiting times, review capacity and post-release defects, not just PR counts.

Three teams, three mechanisms

Control has to be built into execution

Three teams that have moved past the pilot stage show three concrete ways to do it.

01

AXA DCP · Insurance · Europe

Framing before and during coding

Kiro

Shared rules cover technologies, architecture and tests. Human review covers both code and prompts. Junior developers must be able to explain the generated code.

No consolidated gain published.

02

Stripe · Payments · United States

Deterministic checks in the delivery pipeline

Minions, internal agents

Isolated environment, with no real data or production services. Agentic steps and automated checks alternate. After a failed CI run and one fix attempt, control goes back to a human.

1,300+ PRs merged per week, reviewed by humans.

03

OpenAI · Software product · United States

Context and tests as guardrails

Codex

A short instructions file points to versioned specifications and plans. Structural tests and linters enforce the constraints; every error feeds the correction loop.

Around 1,500 PRs in five months, on a new product.

Protect validation capacity

For leads and architects, the risk is clear: supporting their teams while absorbing ever more output to check. Our recommendation: cap work in progress at review capacity, scale controls to risk, and set time aside for learning.

An instruction guides. A permission limits. A test verifies.

A field report, not a rule

Four weeks to understand, not to replace everything

A UK wealth management firm, a regulated platform, and Claude Code to understand the legacy before touching it.

Diagnosis delivered in 4 weeks · 1.7M lines of code · 20 years of legacy

W1AnalyzeInventory, dependencies and risks across code and databases.
W2ValidateBusiness experts correct inferences and ambiguities.
W3DesignTarget architecture, boundaries and cut-over strategy.
W4PlanRoadmap, costs and risks to decide.

Then · 4 weeks of proof of value6 to 8 months of planned modernization+ ~2 h · check added: an instruction in the prompt had not been enough

The lesson to transpose: separate the time for discovery, for proof and for deployment. Business experts’ knowledge and corrections are part of the cost. On the corporate side, bring in the people who know the implicit rules before promising a date. On the startup side, map the dependencies that matter to your feature, not the whole IT estate: an API does not remove integration.

Choose before you automate

Add AI, modernize or change solutions?

Start from the business need, diagnose what exists, compare options, then test and measure. Two questions are enough to open the discussion: does the application still meet the need? Can it evolve easily?

App accessible and under control
Hard or uncertain to evolve
Meets the need
Integrate in a targeted wayTest an AI feature on a precise need, with a verifiable gain.
Modernize what is necessaryClarify interfaces, data and rules, strengthen tests, then integrate. No default rewrite.
No longer meets it
Evolve the functionCompare evolving the product with a targeted replacement.
Transform in stagesIsolate functions and organize a progressive transition.

In every case: compare value, time, full cost, risk and reversibility. And not adding AI remains an option if the value is not proven.

The real economics

The bill does not stop at tokens

ToolsLicenses and APIs, compute, continuous integration, storage.
SetupScoping, integration, test sets, training, documentation.
OperationsSupervision, review, rework, incidents, rule maintenance.

The right metric is the cost per accepted result, at comparable quality, including failed attempts and validation. Anthropic built an experimental compiler with 16 agents for just under $20,000 in API costs, but a large share of the human work went into tests and the feedback setup. Descript says it more than halved its model spend by combining 13 models, thanks to tests and human validation. The real question is not “what do tokens cost?” but “which combination succeeds at the same task at the best full cost?”

Our view

A first win does not prove AI works. It proves you can get it adopted.

We have seen it from both sides of the table. For a B2B startup, adoption and the first win measure its ability to deploy at a client. Without them, it remains a plug-and-play product with a long learning curve, and its renewal is what is at stake. On the corporate side, our engagements almost always start with a PoC that has to tick three boxes at once: teams wanting to use it, feasibility in the real IT environment, and measurable value creation. At a major Asian bank, the PoC was designed and signed in one month.

For a corporate and a startup alike, scaling then becomes the strategic battle. The speed gained in production runs into the organization: who validates, who arbitrates, who owns the result. That is where the real reorganizations begin: review roles, agent permissions, decision circuits, measuring the cost per accepted result. And that is where long-term value is created.

Our role: secure the first win fast, then hold the trajectory as the company scales.

The basis for a working session

Six questions to choose a real team test

Before adding a tool or a new pilot, fill in this sheet for a recent task:

Task and resultWhich task? Which accepted result, for which user?
Starting pointTotal lead time, human time, waiting and defects today.
Expected qualityTests, IT and security requirements, acceptable defect threshold.
AccountabilityWho arbitrates and validates? Who maintains? When is the result measured?
Agent scopeData, allowed actions, permissions, hand-backs to a human.
Budget and stopFull cost, cap on attempts, rollback condition.

An example: generation drops from two hours to one, but review still waits two days. The gain is local. Test waiting and validation before switching models.

Take it further

Want to run it with your team?

First PoC or scaling up: a working session with your teams to choose the test that really measures the result. Preparation, facilitation, deliverables.

Book a meeting with Hack40 →

AI does not remove the need to direct the work. It makes choosing tasks, checking results and the team’s ability to learn even more important. Success is measured where the work becomes useful, not where the code is generated.

Sources and limits
  1. Atlassian, State of Developer Experience 2026: vendor survey, 1,500+ professionals, self-reported results.
  2. Stack Overflow, Developer Survey 2026: 12,734 responses, voluntary sample, perceived usefulness.
  3. He et al., longitudinal study, November 10, 2026: one anonymized company, 802 developers, non-randomized.
  4. AXA DCP, AWS French-language podcast, episode 366: technical interview, no consolidated gain published.
  5. Stripe, Minions, part 2: engineering write-up; PR volume does not measure business value.
  6. OpenAI, Harness engineering: new product; acceleration estimated by the team.
  7. Anthropic, Building a C compiler: prototype; human cost not quantified.
  8. OpenRouter, Descript case study: customer testimonial published by the vendor.
  9. AWS and Kloia, modernization blueprint in 4 weeks: vendor account, no independent audit.

Follow Fabrice Tranier on LinkedIn →

Insights

Notes from the field on AI and scale.

All articles →