Project Atlas
Skeptical delivery team, cost pressure on AI-assisted work.
2.5× development-cost reduction; validated code-quality standards turned skepticism into adoption.
// dev-ai.dev — agentic engineering
Turn ad-hoc AI use into a measurable engineering advantage.
We help engineering organizations reach state-of-the-art agentic engineering through a guided Stage-Up transformation: assess where every team stands, move them up the maturity ladder rung by rung — and prove each step with the metrics your leadership already trusts.
stage-up — transformation
›assess maturity --teams all --dimensions 9
✓baseline set · 9 dimensions · stage profile ready
›run stage-up --target S4 --gates strict
✓phase 1 · foundations — governance + harness
✓phase 2 · practice — maker/checker loops live
phase 3 · compounding — the ratchet installed
85%
of professional developers already use AI coding agents
41%
of new code is AI-generated as of early 2026
4× vs +12%
raw output vs delivered value without verification
// Generation is now cheap. Verification, judgment, and direction are the new craft.
// why now
AI amplifies your engineering culture — for better or worse
Teams that bolt coding agents onto an unchanged process see raw output rise about fourfold while delivered value rises around a tenth — with measurable spikes in code churn, defect rates, and pull requests merged with no review. None of this is an argument against AI. It is an argument against adopting generation without building verification.
Technical debt
Lives in the code. Agents make it cheaper to both create and repay — which way it goes depends on the system around them.
Comprehension debt
Lives in your people: the widening gap between how much code exists and how much any human genuinely understands. Invisible to velocity metrics until something breaks.
Intent debt
Lives in your artifacts — the externalized why behind decisions. The one debt agents cannot repay, because intent must come from a human.
The differentiator in 2026 is not whether your teams use AI. It is whether you have built the system — the factory — and whether you can trust what it ships.
// operating model
The maturity ladder
The engineer's primary output is no longer code but the system that produces code — specs that define the work, agents that implement it, tests and gates that verify it, and feedback loops that route failures back for correction. Every agent is Model + Harness: a decent model with a great harness beats a great model with a bad harness.
// Five stages
S0
Improvised
AI used ad hoc and privately. Copy-paste from a chat window, no shared setup, no spec. Output trusted because it “looks right.”
S1
Assisted
Autocomplete and chat are part of the day. Real individual speed-ups, but every step is hand-driven and held in one head.
S2
Delegated
Agent-sized tasks scoped against a written spec, context curated deliberately, each result verified. Tests ride along with the change.
S3
Orchestrated
Loops and harnesses, not one-off prompts. A maker writes, a different checker verifies, work runs in isolated worktrees, merges are evidence-gated.
S4
Autonomous Agents
Agents run long-running, autonomous loops under guardrails; the factory improves itself. Every failure becomes a rule, skill, or hook. Evals guard prompts like tests guard code. Leverage compounds without quality decay.
// Nine dimensions
The same nine dimensions apply at the individual level (habits and judgment) and the team level (standards and infrastructure), so a person's profile and their team's line up side by side.
01
Intent & Specification
Is the why written down before the agent runs — goals, constraints, definition of done?
02
Context, Memory & Harness
Does the agent get the right context, durable memory, and scaffolding — and not rot as the window fills?
03
Loops, Autonomy & Orchestration
Are you designing systems that prompt agents — or still hand-prompting one turn at a time?
04
Verification & Review
Is review tiered by blast radius, adversarial, evidence-gated, and owned by a human at merge?
05
Tests & Deterministic Gates
Do real tests and immovable CI gates carry the weight human reading no longer can?
06
Safety, Security & Guardrails
Are dangerous actions blocked by construction — sandboxes, hooks, scoped permissions, injection defenses?
07
Comprehension & Judgment
Does the team still understand what it ships — or is the thinking quietly surrendered to the model?
08
Reusable Capability & the Ratchet
Does every mistake become a permanent rule, skill, or hook — so the system compounds instead of repeating?
09
Measurement, Cost & Compounding
Can you measure, trace, and budget the factory — and prove it is getting better, not just faster?
A team is only as mature as its weakest load-bearing dimension. A team that is Stage 4 on tooling but Stage 1 on verification is a Stage 1 risk — the weakest gate is the one that fails.
// free assessment kit
Agentic Engineering Maturity checklists
A two-part maturity assessment for engineering in the agentic era — Factory Edition, version 2026.06.0. Use the interactive checklists in your browser, or download the markdown files and run the assessment inside your own repo. It's the same assessment Phase 0 runs at full depth — and the easiest first step.
Team / Project checklist
Score a team, repository, or organization's standards and infrastructure across the nine dimensions — provable from repo files, configs, dashboards, and recent PRs.
Personal checklist
Score one engineer's habits and judgment — from how intent is specified to how much of the thinking is quietly surrendered to the model.
// Also in the kit
- Framework overview — stages, dimensions, scoring
- Concepts 2026 — the field glossary the checklists assume
Score honestly, find the lagging dimension, pick the next rung — not the summit. Re-score quarterly and watch the profile move.
// the engagement
End-to-end Stage-Up transformation
This is not a workshop series with a certificate at the end. We commit to a measurable stage transition across all nine dimensions for the teams in scope, delivered in four phases and proven against the Phase 0 baseline. Each phase has explicit exit criteria tied to the ladder.
// Phase 0
Diagnose & Baseline
Score every team and key individuals; set the measurement baseline; audit repos and SDLC for AI-readiness. Available as a standalone engagement — immediately useful on its own.
Establishes the starting rung
Maturity profile per team · metric baseline · sequenced Stage-Up roadmap
// Phase 1
Foundations
Governance & security baseline, first shared harness, role-differentiated literacy — the non-negotiables that make delegation safe.
→ Stage 2 · Delegated
AI Use Policy · root AGENTS.md · starter skill/MCP library · trained drivers & reviewers
// Phase 2
Practice
Rebuild the real workflow on live artifacts; stand up the verification system; redesign the SDLC phases around intent.
→ Stage 3 · Orchestrated
Plan→Implement→Test→Review playbook · tiered review · CI gates · maker/checker loops
// Phase 3
Compounding
Engineer self-improving loops; install the ratchet; eval suites; measurement flywheel and internal community.
→ Stage 4 · Autonomous Agents
Guarded automation loops · eval gates · metrics readout · Center of Excellence
Start with a fixed-scope Diagnostic & Baseline (~2–3 weeks). The full Stage-Up transformation runs over roughly two to three quarters, scoped to your risk profile and pace.
// work tracks
A catalog of capability tracks
In an end-to-end engagement the tracks are sequenced across the four phases; they can also be run modularly to target a specific lagging dimension.
Adoption assessment & baseline
Personal + team maturity scoring and the metric baseline that anchors the program.
Educational program
Role-differentiated workshops (dev, BA, QA, architect, manager, leadership) — theory plus practice.
Competence management
Competency matrices and interview/appraisal processes mapped to the maturity stages.
Team & project implementation
Hands-on enablement on live artifacts: the plan/implement/test/review playbook, reusable skills.
SDLC process redesign
Re-shape each phase around intent: requirements→spec, AI-aware review, deterministic gates.
Harness & platform engineering
The factory as shared infrastructure: AGENTS.md, skill/command libraries, MCP configs, hooks, evals.
Verification & quality system
Tiered review, heterogeneous AI reviewers, red/green TDD, mutation testing, evals with rubrics.
Governance, safety & security
AI Use Policy, data classification, BYOT, MCP vetting, sandboxing, injection defenses, auditability.
Loop & orchestration engineering
Loop design, maker/checker separation, fleet scaling to review capacity, guarded overnight loops.
Economics / FinOps for AI dev
Token economy, CapEx→OpEx / TCO modeling, model routing, budgets and quotas, ROI proof.
Leaders, community & success cases
Center of Excellence, champions network, AI retrospectives, demo days, internal competitions.
Production-agent enablement
Build agents as products — memory, evals, observability, deployment — not just code-writing agents.
Managed sustainment
Quarterly re-assessment, harness & eval upkeep, metrics readouts, fractional AI-engineering lead.
// corporate education
Corporate education program
Role-differentiated workshops for developers, BAs, QA, architects, managers, and leadership — theory plus hands-on practice on your real artifacts. The curriculum is sequenced by maturity stage: fundamentals make delegation safe; advanced tracks build the orchestrated, self-improving practice.
Fundamental
toward Stage 2 · Delegated
- 01
Agentic engineering mindset
From autocomplete to autonomy: why some AI-first projects fly and others stall, and what changes in the engineer's role.
- 02
Prompt & context engineering
Context engineering, not prompt tricks: curating what the agent sees, managing context rot, reliable first-pass results.
- 03
Spec-driven development
Writing intent down — goals, constraints, definition of done. Specs an agent can act on and a reviewer can evaluate against.
- 04
Agentic tools & IDE workflows
Cursor, Claude Code, Copilot and friends: harness basics, rules files, AGENTS.md, scoped tool permissions.
- 05
Verification fundamentals
Reading AI diffs like a senior reviewer, tests that ride along with every change, review tiered by blast radius.
- 06
AI safety & use-policy basics
Data classification, what may and may not enter a tool, secrets hygiene, working with synthetic stand-ins.
Advanced
toward Stages 3–4 · Orchestrated & Autonomous Agents
- 01
Harness & platform engineering
Skills, hooks, MCP configuration, sub-agents, durable memory — the shared infrastructure that compounds.
- 02
Multi-agent orchestration
Maker/checker separation, isolated worktrees, parallel fleets scaled to your review capacity — and the orchestration tax.
- 03
Loops & autonomy engineering
Long-running agents with explicit stop conditions, guarded overnight loops, evidence-gated merges.
- 04
Verification at scale
Heterogeneous AI reviewers, red/green TDD, mutation testing, deterministic CI gates that carry the load.
- 05
Evals & the ratchet
Eval suites that guard prompts like tests guard code; every failure becomes a permanent rule, skill, or hook.
- 06
AI economics & FinOps
Token economy, model routing, budgets and quotas, TCO modeling and ROI your CFO recognizes.
// Formats: workshops, embedded team enablement, and train-the-trainer — delivered on your stack and your codebase, not toy examples.
// measurement & roi
Every claim is measured, not asserted
Five instrumented categories — adoption, throughput, quality & risk, economics, compounding — reported on a regular cadence, so velocity can never hide quality. DORA metrics extended with an AI-adoption lens; the ROI model targets total cost of ownership, a number a CFO recognizes.
2.5×
development-cost reduction on one product
93%
AI-generated code reached team-wide, backed by ~1,400 integration tests
7 mo
for 48 engineers across 5 teams — ad-hoc to systematic
// Representative results from a comparable enterprise program
| Metric | Before | After |
|---|---|---|
| Participation in company-sponsored AI training | 10.6% | 66.7% |
| High familiarity & active use of AI tools | 42.6% | 56.7% |
| Systematic prompt- & context-engineering approach | 53% | 70% |
| Daily multi-use of AI tools | 59.6% | 70% |
Alongside these: the share of engineers saving 9+ hours per week rose by 22 points, and the largest activity gains were in writing tests and automation, documentation, and code review (about +40 points each).
// cost optimization
Invert the cost curve
Ad-hoc “vibe coding” looks free — a subscription and a prompt — but hides a compounding operational cost: token burn from trial-and-error loops, a maintenance tax on unstructured code, and expensive late security remediation. A well-built factory inverts the curve: a deliberate upfront investment drops the marginal cost of every subsequent feature. Total cost of ownership is dominated by the token economy and the rework rate — and both are engineerable.
Intelligent model routing
Route routine work to smaller, cheaper models and reserve premium frontier models for judgment-heavy tasks. Routing alone moves a large share of spend off the top tier.
Token budgets & cost tracing
Per-team and per-project budgets, quotas, and cost attribution — spend stays observable and accountable instead of surfacing as a surprise on the invoice.
First-pass success rate
Sharp specs and curated context cut trial-and-error loops — the biggest hidden token burn in ad-hoc agent use. The cheapest generation is the one you don't repeat.
Context engineering & caching
Attach only what the task needs, keep prompts cache-friendly, offload long outputs to files. Smaller windows and cache hits make every call cheaper.
Reusable harness — the ratchet
Skills, rules, and hooks turn one-off effort into shared infrastructure, so the marginal cost of each next feature falls instead of being paid again.
Verification before rework
A failure caught at the gate costs tokens; a failure caught in production costs sprints. The rework rate — not velocity — dominates the TCO.
// Project Beacon: a whole delivery team on a 60,000+ file platform ran on ~$200/month of total AI tooling.
// proof
Selected case studies
Anonymized from real engagements; client and product names are replaced with code names.
Project Beacon
Large regulated US platform, 60,000+ indexed files mixing legacy and modern front-ends.
Full-stack bugs fixed in under a minute; a custom report that took a month now delivered in hours; ~$200/month total AI tooling for the team.
Project Orbit
Greenfield product (~1 year old) architected to be AI-friendly.
~93% of code AI-generated team-wide (up from ~75%); ~1,400 integration tests; a disciplined plan/implement/test/review workflow demoed live to the org.
Harbor & Summit
Business-analyst enablement, not just developers.
BAs now generate requirements grounded in the actual codebase — implementation-aware specs that make downstream AI work effective.
Project Cobalt
Independent solo greenfield delivery for a separate client.
Full MVP (36 requirements, ~395 files) built in ~28–32 engineer-hours via a spec-driven, fully AI-assisted workflow with a QA proof pack.
The transferable lesson: as AI-generated output scales, the constraint moves from writing code to reviewing it. It pays to invest early in AI-assisted review, stronger automated gates, and strong up-front specs — which is exactly what this engagement builds.
// who's behind this
Vyacheslav Koldovskyy, Ph.D.
AI Engineering Transformation Lead · educator, conference speaker and researcher in Agentic Engineering
Author and sole driver of a company-wide agentic-engineering enablement program: 17 hands-on workshops across the full SDLC, competency frameworks with 100+ assessment items and ~300 questions, an AI Use Policy, maturity checklists with companion guides, and hands-on enablement of five delivery teams.
The approach is grounded in a comparable enterprise program that took 48 engineers across five teams from ad-hoc experimentation to systematic practice in seven months — lifting active AI-tool use, cutting development cost by 2.5× on one product, and reaching 93% AI-generated code on another, all under an explicit security policy.
// Track record
- Corporate training delivered for
- SoftServe, Raiffeisen Bank, Ukrainian Delivery Center, InventorSoft, Intelliarts, Langate, MR Lab, KeenEthics
- Conference speaking
- DOU Day 2025 and 2026 · fwdays AI Summit 2026
- Academia
- IT Step University — Associate Professor, Lead of the Agentic AI Research Center · American University — author of an Agentic Engineering course for master's students
// how we start
Find out where your factory stands today
Start with a fixed-scope Diagnostic & Baseline: a maturity profile per team, the metric baseline, and a sequenced Stage-Up roadmap. Low commitment, immediately useful on its own.
- 1Phase 0 — Diagnostic & Baseline (fixed scope, ~2–3 weeks)
- 2Agree the Stage-Up target, scope, and governance guardrails
- 3Run the phased transformation with a regular metrics readout