From prompt to production: a structured AI engineering workflow

AI coding assistants have become incredibly capable. Teams still ship inconsistent output, forget decisions, duplicate work, and cannot predict quality. The problem is not the models. It is the absence of a workflow.

An eleven-stage pipeline, extended from Compozy with two explicit quality gates. Read it end to end once, then link people to the clause they need.

Compozy popularizes an opinionated pipeline where each stage produces explicit artifacts that become context for the next stage. Instead of asking a model to "build feature X," you progressively refine the problem until implementation becomes almost mechanical.

This document extends that pipeline with explicit quality gates for code review and QA. The distinction matters more the more autonomous the agents become: one gate asks whether the code is right, the other asks whether the feature is right. Those are not the same question, and collapsing them is how teams ship well-architected software that does the wrong thing.

Nothing merges until both gates pass. Stages 7 through 9 are a recommended extension rather than core Compozy, but omitting them puts the burden of functional correctness on a review that was never designed to carry it.

Idea

Engineering

Everything starts with a problem statement.

Users should be able to sign in with Google.

No implementation. No architecture. Just the business problem. If the sentence already names a technology, it is not an idea yet.

PRD

Engineering

Transform the business idea into clear product requirements. The PRD stays implementation-agnostic, and it answers:

Who is this for?
Why is this valuable?
What problem are we solving?
What are the success criteria?
What are the user stories?
What are the edge cases?
What is explicitly out of scope?

Skill

cy-create-prd

Produces

Product requirements document
User stories
Acceptance criteria
Business constraints

Technical specification

Engineering

Once the product is understood, engineering designs the solution. The TechSpec defines architecture, APIs, database changes, security considerations, performance expectations, risks, migration strategy, and technical ADRs.

The biggest improvement over traditional prompting lives here: refusing to make assumptions. When business rules or architectural boundaries are unclear, the agent stops and asks instead of guessing. A guess at this stage becomes a constraint by stage 5.

Skill

cy-create-techspec

Produces

Technical specification
Architecture decisions
ADRs
Implementation strategy

Task breakdown

Engineering

Large features decompose into small, independently executable tasks. Each one carries scope, dependencies, acceptance criteria, complexity, and status.

The sizing rule is simple: small enough that an autonomous coding agent can safely finish it.

Skill

cy-create-tasks

Produces

task-001.md
task-002.md
task-003.md
...

Task execution

Engineering

Implementation begins. Each coding agent receives the task, relevant project context, workflow memory, coding standards, and acceptance criteria. It executes one well-defined task at a time rather than an entire feature in one enormous prompt.

Skills

cy-execute-task cy-workflow-memory

Produces

Code
Updated task status
Persistent project memory

Code review

Engineering

Quality gate 1. Engineering quality only. Does not ask whether the feature works.

Implementation is the first quality gate, not the finish line. Review asks whether the architecture is correct, the code maintainable, the security sound, the performance unregressed, the conventions followed, and the solution no more complex than it needs to be.

Issues become structured review artifacts instead of disappearing inside chat history. Review continues until no significant issues remain.

Skills

cy-review-round cy-fix-reviews

Produces

reviews/
    issue-001.md
    issue-002.md

QA report

Validation

Not part of core Compozy, but a natural extension. Before running any automated test, generate the plan. The report covers happy paths, edge cases, regression scenarios, accessibility, offline behavior, error handling, performance, security, and the browser and device matrices.

The output is a reusable test plan. Not test execution.

Skill

qa-report

QA execution

Validation

Quality gate 2. Functional quality only. Assumes the code already cleared gate 1.

Autonomous QA agents execute the plan. Playwright, Browser Use, Flutter integration tests, Cypress, API tests, contract tests: the stack is a detail, the separation is the point.

Skill

qa-execution

Artifacts

Screenshots
Videos
Logs
Failed assertions
Coverage reports

Splitting planning from execution is what makes validation reproducible, reviewable, and automatable. A plan written during execution is a rationalization of whatever the agent happened to test.

Regression review

Validation

Before shipping, consolidate everything into a release report: whether all acceptance criteria were met, which bugs remain, what changed, what risks remain, and what was intentionally deferred.

This is the release decision document. Someone has to be able to say no here.

Ship

Release

Merge only after every gate passes. At this point the feature carries requirements, architecture, tasks, implementation, review history, QA evidence, and a regression report. Every engineering decision is traceable.

Capture decisions

Release

The most valuable idea in Compozy: successful implementations should not disappear into chat history. After shipping, capture the architectural decisions, reusable patterns, lessons learned, coding conventions, and project-specific guidance.

Future agents get smarter because they inherit verified project knowledge instead of rediscovering it. Skip this stage and every feature starts from zero.

Skill

cy-capture-decisions

Produces

Engineering memory
Long-term project knowledge
Reusable implementation guidance

Why two gates

The most important change in this workflow is refusing to let one review answer two questions. Code review and QA are different disciplines with different failure modes, and merging them means one of them gets done badly.

Gate 1: code review

Is the code right?

Is the architecture sound?
Is the code maintainable?
Is it secure?
Is it performant?
Does it follow project standards?

Gate 2: QA

Is the feature right?

Does the feature work?
Are edge cases handled?
Does it regress existing functionality?
Does it work across supported environments?

Separating them lets specialized agents and specialized skills own each responsibility. It also makes failure legible: when something ships broken, you know which gate missed it.

Artifacts produced

Every stage leaves something behind. This is the complete paper trail for one feature.

Idea
 └── idea.md (optional)

PRD
 └── prd.md

TechSpec
 ├── techspec.md
 └── ADRs/

Tasks
 ├── task-001.md
 ├── task-002.md
 └── ...

Implementation
 ├── source code
 └── workflow memory

Review
 └── reviews/
        issue-001.md
        issue-002.md

QA
 ├── qa-report.md
 ├── screenshots/
 ├── videos/
 └── logs/

Regression
 └── regression-report.md

Knowledge
 └── decisions.md

Skills

Core workflow
Stage	Skill
Product requirements	`cy-create-prd`
Technical specification	`cy-create-techspec`
Task breakdown	`cy-create-tasks`
Task execution	`cy-execute-task`
Workflow memory	`cy-workflow-memory`
Code review	`cy-review-round`
Review remediation	`cy-fix-reviews`
Final verification	`cy-final-verify`
Capture decisions	`cy-capture-decisions`

Companion skills, for more autonomous runs
Skill	Purpose
`cy-spec-preflight`	Gather project context before writing specifications
`cy-spec-peer-review`	Independent specification review
`cy-impl-peer-review`	Independent implementation review
`cy-loop-tasks`	Fully autonomous task execution loop
`cy-tasks-tail-qa-pair`	Append QA report and QA execution tasks automatically
`cy-research-issues`	Convert research into actionable engineering tasks
`cy-idea-factory`	Transform ideas into structured project proposals

Linked entries resolve either in the Compozy legacy/v0.2 tree or in the pedronauck/skills catalog. The rest are named in the workflow but have no published implementation yet.

Sources

Compozy

Featured skills

Research

Closing

Most AI coding sessions

Prompt
Code
Hope

A production workflow

Business problem
Requirements
Architecture
Planning
Implementation
Engineering review
Functional validation
Regression review
Institutional knowledge

Every stage produces explicit artifacts. Every decision is reviewable. Every quality gate is intentional.

That is the difference between prompting an AI and engineering with one.

From Prompt to Production. An eleven-stage AI engineering workflow, extended from the Compozy pipeline with explicit code review and QA gates.