Same PRD, four stacks, zero LLM calls — and EU AI Act Annex IV from the same spec

anioko1 — Mon, 08 Jun 2026 22:05:37 +0000

Last month I published spec-driven development across NestJS, Go, Spring Boot, Laravel, and Rust. This follow-up narrows to the four stable web stacks and adds the compliance angle teams are asking about before August 2, 2026.

The problem with prompt-driven codegen

Re-prompt the same PRD in Cursor or Copilot and you get different schemas, auth bugs, and divergent APIs. For demos that's fine. For production and regulatory documentation, it's a liability.

Spec-to-application treats the PRD as a formal model and compiles it — same input, same output, no LLM in the generation step.

Try it in 90 seconds

git clone https://github.com/Anioko/spec-driven-development.git
cd spec-driven-development
chmod +x demo.sh
./demo.sh           # FastAPI (default)
./demo.sh flask
./demo.sh django
./demo.sh nestjs    # requires Node 18+

Each command runs the same examples/sample-prd.md through a deterministic pipeline:

PRD → manifest → genome → stack-native app → directory/ZIP

No API key. No "it depends on the model."

Where this sits vs GitHub Spec Kit

Tier	What it does
Agent workflow (Spec Kit, Kiro)	Spec files guide an LLM to edit your repo
Spec compiler (archiet-microcodegen)	Spec compiles into a new bootable application

Full comparison: archiet.com/vs/spec-kit and the SDD guide on GitHub.

EU AI Act: same genome, code + Annex IV

If you're building high-risk AI for the EU market, Annex IV technical documentation is the bottleneck — not the framework choice.

Free risk classifier — https://archiet.com/tools/eu-ai-act-risk-classifier

Same blueprint that emits Flask/NestJS/etc. also emits compliance/eu_ai_act/article_11_technical_documentation.md
Traceability — Annex IV §2 rows link to routes, entities, tests (Flask example)
Stack boilerplate pages: Flask · FastAPI · Django · NestJS

Open source vs platform

Open source (archiet-microcodegen)	Platform (archiet.com)
Deterministic PRD → one stack	15 stacks + frontend + mobile
Bootable API scaffold	Delivery gates, compliance overlays
demo.sh	Professional+ Annex IV bundle

Vibe Coding vs. Production Reality: An ROI Breakdown

anioko1 — Sun, 07 Jun 2026 13:25:49 +0000

Every CTO has seen the demo. Type a few sentences into an AI chat, and within minutes, a fully functional task manager, dashboard, or customer portal appears. The promise of “vibe coding”—where developers describe features in plain language and AI generates the code—is seductive.

In early 2026, 92.6% of developers reported using an AI coding assistant, and over a quarter of production code is now AI-authored. Gartner projects global SaaS spending will reach $512 billion by 2028, but the market has already noticed seismic shifts. Microsoft CEO Satya Nadella has predicted traditional SaaS applications may collapse in the coming agentic AI era.

The question isn’t whether AI will change software development—it’s whether you will adopt AI effectively before your competitors do. For enterprise and solution architects, the opportunity is to move beyond weekend prototypes and build production-grade internal tools at a fraction of the cost of traditional SaaS.

This analysis strips away the hype and presents a clear ROI framework, contrasting standard “chat-first” vibe coding with a spec-driven approach exemplified by platforms like Archiet.com.

The Real Cost of Building Internal Software in 2026

First, establish the baseline. Traditional agencies building custom software in 2026 charge:

MVP projects

Traditional agency: $50,000 – $120,000
AI-first agency: $15,000 – $50,000

Production apps

Traditional agency: $100,000 – $500,000
AI-first agency: $50,000 – $300,000

For a typical enterprise internal tool (an operations dashboard, for example), a traditional vendor might quote $200,000 to $350,000 for development, with an additional 3 to 6 months of timeline. Conversely, a vibe-coded project costs between $15,000 and $60,000 in tooling and engineering time.

That suggests a cost reduction of 70 to 80 percent. The math appears compelling—until you examine where these projects often stall.

Hidden Costs: The 80% Failure Rate of Ad-Hoc Vibe Coding

A standard MVP with a traditional agency costs $60,000–$150,000 and takes three to six months, putting software validation out of reach for many businesses. AI-assisted development shifts the economics: MVPs now run $15,000–$35,000 at AI-powered agencies, a 3–5× speed improvement. Small teams report roughly 68% faster delivery using vibe coding tools like Cursor.

However, the ad-hoc, iterative approach to AI development (pure “vibe coding”) has a well-documented failure mode: 80% of AI-coded projects fail before seeing real users due to architectural debt, security gaps, and maintenance chaos.

Experienced architects know this pattern well. One marketing consultant built a client portal using conversational AI. By prompt ten, deleted clients still appeared in the sidebar. By prompt twenty, she had three different ways of handling client data scattered throughout the code, none communicating properly. The AI, lacking a mental model of the overall architecture, simply patched the surface with each request.

This is the central tension of vibe coding: it’s excellent for prototyping but brittle for production.

Real Cost Tracking Example: Logistics Dashboard

Consider a logistics dashboard project where a team meticulously tracked all costs:

Traditional development

Development time: 10–12 weeks
Development cost (labor): $70,000 – $85,000
AI API & tooling: N/A
Total cost: $70,000 – $85,000

Vibe-coded project

Development time: 6 weeks
Development cost (labor): ~$14,960
AI API & tooling: $431
Total cost: ~$15,400

The labor hours for the production build came in at roughly $14,960, while the AI API bill was a negligible $431. The tokens were not the expensive part. What proved costly was re-prompting loops, session context-setting, and cache token inflation.

Additional Enterprise Metrics

Development cost reduction → up to 70%
Defects on day one → up to 50% fewer (with autonomous testing & quality gates)
Backlog turnover → up to 40% faster
Critical bugs in production → 60% fewer (with spec-driven development)
Deployment cycles → 40% faster (with spec-driven development)

Teams using structured, spec-driven AI coding achieved 60% fewer critical bugs and 40% faster deployment cycles compared to ad-hoc AI coding. Enterprises using structured AI-assisted development report up to 70% lower development costs, up to 50% fewer defects on day one, and up to 40% faster backlog turnover.

The key variable is architecture.

The Architecture Gap: Why Most AI-Generated Code Is Not Production-Ready

Standard vibe coding fails at the infrastructure layer. It overlooks authentication, database design, and compliance, treating security as an afterthought. Tools like Cursor, Lovable, and Bolt can generate a beautiful front end, but they rarely embed enterprise governance into their outputs.

One of the most persistent failures is the “Auth Wall” —adding authentication to an AI-generated app built without it. Authentication affects every layer: database tables need user IDs, foreign keys need restructuring, APIs need middleware to verify tokens, and frontends need to handle login states and protected routes. These decisions cannot be retrofitted. Vibe coding without considering auth from the start builds a single-user app that cannot magically become multi-user later.

Moreover, 74% of developers using AI report increased productivity, completing tasks in just over half the time, with routine boilerplate work seeing a 51% speed boost. Yet despite widespread adoption, overall productivity gains have plateaued at roughly 10% since AI tools went mainstream, with most time savings absorbed by increased review and debugging overhead.

Speed without structure is simply building technical debt faster.

The Solution: From Freeform Chat to Spec-Driven Development

Spec-driven development (SDD) transforms the workflow. Instead of jumping straight into prompting an AI to “build me a task management app,” you write a detailed specification first. This spec becomes the project’s constitution, the single source of truth that governs every line of code your AI generates.

The concept gained serious traction when Thoughtworks named SDD one of their key engineering practices for 2025. Their research showed that projects following SDD principles had 60% fewer critical bugs in production and 40% faster deployment cycles compared to ad-hoc AI coding approaches.

What Sets Archiet Apart in the SDD Space

Among the emerging SDD platforms, Archiet.com addresses the core “architecture gap” left by conventional AI coding tools. It is designed for enterprise architects and solution architects, not just solo developers.

Instead of relying on conversational back-and-forth, Archiet uses a single Product Requirements Document (PRD) file as the source of truth. A text file goes in; a working application comes out. Its pipeline—Parse PRD, generate an Architectural Genome, then produce validated code—embeds enterprise constraints upfront rather than patching them on later. The tool explicitly aims to eliminate the “6‑week infrastructure tax” that every startup wastes rebuilding authentication, migrations, and compliance.

From a single spec, Archiet generates:

Scored architecture blueprints
SOC2 / ISO27001 / GDPR compliance reports
Production code across 12 technology stacks

It provides MCP (Model Context Protocol) servers, allowing integration with Claude Desktop, Cursor, and Continue.dev. By separating the spec from the code, it maintains a consistent architectural vision regardless of how many times the AI regenerates the implementation.

In practice, this means an architect can write a PRD defining entities, user stories, integration points, and security constraints. Archiet then produces a complete, deployable application with full CRUD operations, JWT authentication with HttpOnly cookies, Postgres 16, and per-user data isolation—before the architect has finished their morning coffee.

How Archiet Compares to Other SDD Approaches

Traditional AI Coding (Copilot, Cursor)

Source of truth: Conversation thread / patch history
Architectural consistency: Low—drifts with each prompt
Compliance output: None—manual audit required
Production code generation: Fragmented, inconsistent
Enterprise integration: Requires manual wiring

Archiet

Source of truth: Single PRD file
Architectural consistency: High—spec governs all generations
Compliance output: SOC2/ISO27001/GDPR reports auto‑generated
Production code generation: Validated across 12 stacks
Enterprise integration: MCP servers for Claude, Cursor, Continue.dev

MCP Integrations

Archiet provides Model Context Protocol servers, allowing enterprise architects to invoke its code generation from Claude Desktop, Cursor, and Continue.dev. This seamlessly integrates spec-driven development into existing enterprise workflows without requiring dedicated IDEs.

SDD at Scale: The Open-Source Alternative

For teams preferring open-source tooling, the microcodegen family of CLIs implements the same spec-driven pipeline. These tools parse a PRD using regex rather than LLMs, extracting entities, field definitions, user stories, and relationships into a language-agnostic Manifest. From there, an Architectural Genome is generated, mapped to standard ArchiMate 3.2 categories, and finally transformed into validated code for stacks including NestJS, Go, Spring Boot, Laravel, and Rust.

These approaches demonstrate the maturity of SDD: it is no longer an experimental concept but a production-ready methodology backed by both commercial platforms and open-source tooling.

Implementation Strategy: A Phased Approach for Enterprise Architects

For enterprise architects considering an SDD approach, a measured pilot program is recommended.

Phase 1 (Month 1)

Identify a low-risk internal tool, such as an HR request tracker or a compliance reporting dashboard. Have a senior architect write a PRD based on existing business requirements. Use a platform like Archiet to generate the initial architecture and code.

Phase 2 (Month 2–3)

Deploy the tool to an internal team of 50–100 users. Track defect rates, deployment velocity, and feedback loops. Compare against a traditional build estimate from an agency.

Phase 3 (Month 4+)

If successful, expand to more critical systems while maintaining human oversight at the architecture validation stage. Remember that SOC2 and ISO27001 do not auto-approve just because an AI generated the code—governance and audit trails remain essential.

When Not to Use Spec-Driven Development

Spec-driven development is not a universal replacement. Avoid it for:

Core systems of record where failure has catastrophic impact (ERP, CRM core)
Highly regulated environments that demand formal verification of every line (medical devices, avionics)
Security-critical systems like authentication or payment processing—use battle-tested libraries instead
Long-lived systems where future maintainers may not have access to the same AI tooling

Conclusion: The New Role of the Solution Architect

The rise of AI-assisted coding does not spell the end for solution architects. On the contrary, it elevates their role. The architect of 2026 is no longer a diagram-drawer or a detailed code reviewer. They are an orchestrator of AI tooling, a validator of generated blueprints, and a guardian of enterprise governance.

The core value shifts from implementation to strategy. The architect decides:

Which systems are suitable for SDD
Writes the specifications that govern AI behavior
Negotiates trade-offs between speed and long-term maintainability
Ensures compliance remains intact across AI-generated components

As the economics shift, the competitive advantage accrues to organizations that combine SaaS data moats (for core systems of record) with spec-driven AI agility (for internal tooling). The team that takes six weeks to build an internal dashboard while the competition takes six months has won—provided that dashboard is built on a foundation that won’t crumble under real-world use.

The tools exist. The methodology is proven. The question is no longer whether to adopt AI architecture platforms, but who will be the first in your organization to champion them.

Which internal process in your organization could be rebuilt for 80% less cost this quarter? What’s holding you back?

Sources

Vibe Coding vs. Traditional Development: Costs, Benefits, and ROI – Attract Group

🔗 attractgroup.com
How We Reduced Vibe Coding Costs in AI-Assisted App – Bacancy Technology

🔗 bacancytechnology.com
What Is Vibe Coding — And What It Actually Means for Your Business – Kodework

🔗 kodework.com
Enterprise Use Cases for Vibe Coding: Real Results and ROI Examples – Hexaware

🔗 hexaware.com
93% of Developers Use AI. Why Is Productivity Only 10%? – ShiftMag

🔗 shiftmag.dev
What Custom Software Actually Costs in 2026 – GlobalBit

🔗 globalbit.co.il
Spec-Driven Development Without an IDE – Dev.to (Archiet)

🔗 dev.to
Why vibe coding fails (and spec-driven development fixes it) – Full Stack Creators

🔗 fullstackcreators.com
Spec-driven development: stop AI code chaos before it starts – Full Stack Creators

🔗 fullstackcreators.com
Enterprise Vibe Coding Blueprint – Cognizant

🔗 cognizant.com

DEV Community: anioko1