AI for IT and product teams
Industrialize
development with AI
From ad hoc prompts to an AI-Native SDLC with methodology, our own accelerators and human verification at every step.
transformed
sprints
speed
Rules over tools.
The model must NOT be the source of truth.
The chat must NOT be the system.
The code must NOT be the only artifact.
We need external, governed and verifiable state.
The broken promise
We were told AI would make us 10x more productive. In some cases we did speed up. In many others, we're generating more code... and more problems.
AI's impact isn't automatic. It depends on the way you work.
The difference between the teams winning with AI and those getting stuck isn't budget, or size, or access to the latest API. It's understanding that AI isn't just one more tool in the catalog: it's a change in how you design processes, teams and decisions.
real productivity
METR 2025 study: developers using AI were 19% less productive — even though they perceived a +20%. The gap between perception and reality is the symptom of a broken system.
more security issues
Fortune 50 study: teams with AI generate 3-4x more code than their peers but introduce 10x more security vulnerabilities in the same period.
The three real brakes on development with AI
LLMs have structural limits. If you don't design for their limits, you work against them.
Limited memory
It can't sustain large systems without losing coherence. Asking the model to "remember the whole architecture" is asking it to do what by design it can't.
Hallucination
It optimizes for plausibility, not for truth. It generates code that "looks like it works" even when the underlying assumption is false. Spotting that at a glance is impossible.
Context drift
Long contexts degrade focus and precision. The more code you pile into the agent's window, the worse it reasons — exactly the opposite of what intuition suggests.
Agents aren't yet reliable enough for complex engineering.
The solution isn't to abandon AI.
It's to change your role.
From writing code to designing context, rules and verification.
This is what we call industrializing development with AI. And to do it, buying more tools isn't enough: you need a system. We call it onext AI-Accelerated Development.
Three pillars.
One single system.
The whole solution rests on three pillars that onext teaches in its internal training and now brings to the product.
Human-on-the-Loop
The AI proposes, the human governs. Human validation is mandatory at every critical gate, not informal. It's an explicit role with its own artifacts and metrics.
- Structured validation in specs and in code
- Reviewer role (equivalent to a human PR)
- Context Owner who maintains the system's rules
Rules Over Tools & Context Engineering
Tools are interchangeable; rules are what define the system. External, governed and verifiable state — not the model's memory or the chat.
- → Project constitution + subagents + MCPs
- → Commands, skills, hooks, curated models
Spec-Driven Development
Specifications are the source of truth, not the generated code. A well-written spec is traceable, verifiable and reusable.
- → Specs as the primary artifact, code derived
- → Pre-commit validation against the constitution
- → Traceability of every line of code to an intent
The AI-Native SDLC Loop
The natural evolution of the DevOps loop when there are agents in the flow. Seven stations, two constitution gates, two tools (Product Accelerator and SDD Accelerator) and a human-validation outline.
Accompanies the Intent → Specify → Validate stations. Turns product intent into a structured spec ready for the agent to consume.
Accompanies the Generate → Verify → Deploy stations. Injects the spec into the agent and blocks any code that doesn't respect the project constitution.
At the Constitution Gate, at the crossing of the two loops, product intent becomes an implementable spec. If the spec doesn't respect the project's immutable rules, it doesn't reach the agent. The whole cycle is supervised by the human team.
Two onext accelerators.
One complete chain.
Accelerators built on the open Claude Code standard —not proprietary software you install and depend on—. We configure them on your stack, your team uses them and they stay with you. Without them, the pillars are a manifesto. With them, they're an operating system.
onext Product Accelerator
From idea to spec, structured and repeatable
An accelerator on Claude Code (open standard, no lock-in) that orchestrates 5 specialized agents across structured product-definition workflows. From a raw idea to a specification ready for development, with quality gates at every phase transition.
- → 5 specialized agents: orchestrator, product-consultant, ux-designer, sdd-specifier and reviewer
- → 4 workflows: idea-to-feature (6 phases), quick-improvement (3), spike (2), audit (2)
- → 25 skills across 7 domains: discovery, research, persona, UX design, specification, validation and setup
- → 8 automated quality gates: phase gate checker, ambiguity guard, scope creep detector, decision logger…
- → Artifacts: Lean Canvas, JTBD, empathy maps, user flows, behavior flows, acceptance criteria, business rules, SDD consolidation
- → Native integration with Figma, Jira, Storybook and the project's compliance configuration
That the engineering team receives consolidated, validated specifications, with no ambiguities or decisions left hanging. Each phase produces a concrete artifact and no workflow moves silently over incomplete work.
onext SDD Accelerator
Specifications the AI respects, with verification at every commit
It integrates Spec-Driven Development directly into the technical team's flow. It governs external state and validates that the code respects the project's rules.
- → Specification templates adapted to the project's stack
- → Project "constitution": immutable rules the agent respects
- → Pre-commit validation against the spec (structure, naming, dependencies, coverage)
- → Merge-blocking hook if the generated code doesn't comply
That code generated fast by AI isn't also inconsistent code. It turns agent output into code that respects the project's architecture, conventions and rules.
How we work alongside you
Four phases that overlap in time, they don't run in sequence. Throughout the whole engagement your team keeps shipping product: no phase requires pausing sprints.
We deploy and configure onext's two accelerators on your stack —and they stay with you—. We define the project constitution together and create the spec templates. A complete product → spec → code chain working end-to-end.
Pair programming between onext and client developers. AI-specific code review. Refining the constitution based on what fails in practice. Weekly retros. Individual coaching for the team's 3-5 creators.
Dual specialization: creators (10-20% of the team) and advanced users (the rest) receive specific training. Formal transfer of the constitution, templates and metrics. Post-engagement sustaining plan with 6 months of accelerator support included.
Two ways in
The same system, two intensities. You can start with the quick-start and scale to the full program when the team asks for more, or go straight into the end-to-end transformation.
AI-accelerated development
We multiply the team's speed ×5-10 with the Spec-Driven Development methodology and the onext SDD Accelerator. Hands-on training on your real code and weekly follow-up. Without freezing a single sprint. The lowest-barrier entry point.
- Diagnosis of the current stack, workflows and AI adoption (3-5 days)
- SDD framework: project constitution, onext SDD Accelerator and spec templates for your stack
- Hands-on training: hands-on workshops and pair programming with onext seniors
- Follow-up: weekly metrics + 3 months of post-implementation support
Ideal if your team is at its limit, there's pressure to innovate with AI and you need tangible results in 60 days — not PowerPoints.
End-to-end SDLC transformation
We redefine your lifecycle end to end: the 3 pillars, the AI-Native SDLC Loop and onext's two accelerators. Organizational redesign, human-agent lanes and live metrics. To industrialize development with AI, not just speed it up.
- → The 3 pillars and the AI-Native SDLC Loop implemented in your team
- → The two accelerators (Product + SDD) in production end-to-end
- → Operating model redesign: human-agent lanes and RACI per process
- → Formal transfer + 6 months of accelerator support included
Ideal if you want to change how processes, teams and decisions are designed around AI — the full arc described above.
Outcomes we promise
Three verifiable metrics. Baseline before the engagement, target at the end.
Between "deciding to do something" and "having it in production", measured on a critical client flow.
AI-generated code that passes linters, test coverage and post-merge rework rate.
Tasks that move to supervised agents: discovery, specs, first draft, structured QA.
What people usually ask us
Are we really not going to lose a single sprint?
Correct. We work in parallel with the team's sprint. Pair programming is voluntary and done with 1-2 rotating developers while the others keep working normally. No phase requires pausing deliveries.
Does it work with our stack? (we use Python/Java/React...)
Yes. We've implemented AI in teams using Node.js, Python, Java, PHP, React, Vue, React Native, Go... The framework is language-agnostic. We adapt it to your stack during the diagnosis.
When do we start seeing results?
Quick wins (x2-3) usually show up in week 2-3. The bigger results (x5-10) consolidate from week 4-6 onwards. We measure it every week with objective metrics (velocity, story points, feature lead time).
What's the difference between the quick-start and the full program?
They're two intensities of the same program. The quick-start (4-8 weeks) implements the SDD methodology and the onext SDD Accelerator to multiply the team's speed with hands-on training. The full program (12-16 weeks) redesigns the SDLC end to end: the 3 pillars, the AI-Native SDLC Loop and onext's two accelerators, with organizational redesign and human-agent lanes. You can start with the quick-start and scale to the full program, or go straight into the full one.
What is Spec-Driven Development and why do we need it?
Spec-Driven Development (SDD) is an emerging methodology that changes how teams work with AI to write code. Instead of every developer writing ad hoc prompts and hoping the AI gets it right, the team defines structured specifications — a project 'constitution' with immutable rules the AI always respects, spec templates for each type of task and a validation flow at every commit. The result is AI-generated code that respects the project's architecture, conventions and rules consistently.
What do we take away when it's over?
Your team keeps the complete framework: project constitution, specification templates, prompt playbook and post-implementation support (3 months in the quick-start, 6 months of accelerator support in the full program).
Related insights
The conceptual framework behind onext AI-Accelerated Development, published in the open. Start with the first one if you want to understand why the problem is organizational before it's technical.
The model isn't the source of truth. The chat isn't the system. Code isn't the only artifact.
The METR paradox: +20% subjective productivity, −19% real. The reason is the absence of three disciplines almost nobody applies. Claim 1: the model isn't the source of truth → project constitution. Claim 2: the chat isn't the system → workflows with quality gates. Claim 3: code isn't the only artifact → Spec-Driven Development. Three installable antidotes. An honest Karpathy quote to close.
HTML beats Markdown for artifacts that live: the Spec-Driven Development decision table
Of the 14 Spec-Driven Development artifacts, 8 migrate to HTML and 5 stay in Markdown. The decision isn't ideological — it's operational: the larger the artifact and the longer its lifespan, the more sense HTML makes. Includes the full table, the reframe of the Tech Lead as a "compute allocator" per Thariq Shihipar, and the update to onext's AI Engine method as of May 2026.
Spec-Driven Development: The methodology that turns AI into controlled, predictable code
85% of teams use AI to code with ad hoc prompts. Only 15% use structured specifications. SDD is the emerging methodology that brings control, predictability and quality to AI-assisted development.
AI-accelerated dual-track Scrum: how to implement it in your team
You bought AI licenses for your team and the velocity is still the same. It's the number-one complaint from CTOs in 2026, and it almost always has the same root: AI accelerates writing code, but a team's bottleneck is rarely writing code — it's deciding what to build and verifying that it works. A dual-track Scrum separates the lane that decides (discovery) from the one that builds (delivery via Spec-Driven Development), with AI doing the heavy lifting of both and the human signing off at the gates. How to implement it in 8 weeks without stopping delivery, what to measure and why in the teams onext transforms it's worth ×7 in velocity with 0 sprints lost.
Context engineering: the discipline that levels up teams with and without AI
80% of teams use AI individually. Only 5% treat context as an engineering asset. Context engineering is the practice that separates teams that experiment from teams that master AI. From Skills to SDD: the complete evolution.
Month 6: why your dev team's AI transformation breaks at that point — and the sustaining system that prevents it
The first 3 months of AI transformation are enthusiasm with method. By month 6, most teams return to baseline without knowing why. The collapse always follows the same order: stale workflows → false positives in quality gates → silent bypassing → back to square one. The sustaining system that prevents it has three pieces: a rotating owner, a single health metric and a monthly 30-minute ritual.
The 70% gap: your AI adoption in the development team isn't a technical problem — it's an organizational problem
More than 40% of agent-based projects will be cancelled before 2027 (Gartner). After 12 transformations in development teams, the pattern is consistent: 70% of AI success isn't technical. The 5 organizational dimensions no tool solves on its own. Four questions to tell a technical problem from an organizational one in your next committee. Includes the METR paradox and a Karpathy quote.
Why most LLM projects fail (and how to turn them into systems that actually work)
95% of AI pilots deliver no P&L impact, according to MIT. 90% of employees use AI on their own, but 68% don't tell anyone. The problem isn't the technology: it's treating LLMs as individual tools instead of systems integrated with context, flow and control.
From tasks to workflows: AI agents already run complete multi-stage processes
57% of companies already use AI agents to run multi-stage workflows, and 81% plan to tackle more complex cases in 2026. But moving from isolated tasks to complete processes requires clear specifications, structured context and an oversight model that most teams don't yet have.
Not ready for the program yet? Before investing in transformation, size the gap. Our interactive 16-question checklist gives you, in 5-7 minutes, a diagnosis of where your team stands today. Free. No strings attached.
Take the free diagnosis
Ready to
industrialize your development?
In 30 minutes we can assess the real state of your SDLC and design a first redesign step your team can execute without stopping deliveries.