QualityLayer: Implementing a Seven-Step Software Development Workflow with Coding Agents

From "Letting AI Write Code" to "Letting AI Write Code Following an Engineering Workflow"

AI coding assistants can already write code, but many developers have encountered this dilemma: the Agent generates a large chunk of code that looks usable, but you can't confirm whether it actually meets the requirements, whether the tests are sufficient, or whether edge cases are handled. The root cause is that most tools only focus on the "generation" step, while real software development is far more than that.

QualityLayer, ranked #19 on Product Hunt, attempts to solve this problem. Its approach is straightforward: break a single code change into seven steps, giving the coding Agent clear outputs and checkpoints at each stage. The seven steps are: Discuss, Research, Plan, Outline, Implement, Verify, and Review.

Unlike the common "one-sentence code generation" experience, QualityLayer emphasizes that no code modifications occur until you approve the plan. You can comment directly on diagrams and a clickable interface, and the Agent only starts working after you confirm the Plan. This design moves human review to before coding rather than after the fact.

Core Design of the Seven-Step Workflow: Plan-First and Dual-Agent Verification

In QualityLayer's seven-step workflow, two mechanisms deserve the most attention.

Plan approval as the gate for code changes. After the four phases of Discuss, Research, Plan, and Outline are complete, you need to explicitly approve the Plan before the Agent proceeds to the Implement phase. This means the Agent must first understand what you want to do, research the relevant context, provide an implementation approach and structural outline, and then you make the call. This "align first, execute second" model stands in clear contrast to many tools that generate code directly.

Independent review by a new Agent. After implementation is complete, the Agent that wrote the code does not check its own work; instead, a new Agent that did not participate in coding is launched to verify the result against your original requirements. This is a very pragmatic arrangement—the same Agent checking its own output is prone to blind spots, while having an Agent that "didn't write this code" review it is closer to a real team's code review scenario.

In addition, the Agent builds using a test-first approach, meaning tests are written before features are implemented. The Verify phase is responsible for running verification. The entire workflow embeds two engineering practices—test-driven development and cross-review—into the Agent's way of working.

Test-first is the core practice of test-driven development (TDD): before writing functional code, first write failing test cases based on requirements, then implement code to make the tests pass, and finally refactor. This order forces developers (or Agents) to clarify "what the completion criteria are" before starting work, avoiding a disconnect between implementation and expectations. In AI coding scenarios, test-first has an additional layer of value: the test cases themselves become executable specifications, and the subsequent verification phase can automatically run these tests to objectively judge whether the implementation meets the requirements, rather than relying on the Agent's self-reporting.

Independent Agent cross-review draws on the code review practice in software engineering, but makes a key adjustment: the reviewer is an Agent with a clean context that did not participate in coding. In real teams, reviewers are usually unfamiliar with the details of the code under review, making it easier to spot issues the author overlooked; similarly, having an Agent that "didn't write this code" verify the result against the original requirements can reduce self-confirmation bias. The limitation of this approach is that the independent Agent lacks the implicit context from the implementation process and may propose unrealistic modification suggestions, so humans still need to make the final judgment.

Compatibility and Local Execution

QualityLayer supports Claude Code, Codex, Cursor, and four other coding Agents—seven tools in total. Users use their own subscriptions and do not need to purchase additional model services. The tool itself runs on your own computer.

This design is friendly to developers who already have coding Agent subscriptions—you don't need to switch your existing toolchain, and QualityLayer is more like a process management layer stacked on top of the Agent. Local execution also means code and context never leave your machine, making it more suitable for privacy-sensitive scenarios.

The project is open source on GitHub at github.com/maxritter/qualitylayer.

Coding Agent refers to an AI system that can autonomously call tools, read and write files, and execute commands to complete programming tasks, as distinct from assistants that only provide code completion. Claude Code, Codex, and Cursor are current mainstream representatives, each tied to different model services and subscription systems. QualityLayer does not include built-in models; instead, it acts as a process layer on top of these Agents, meaning it needs to adapt to each Agent's interfaces or modes of operation. This "decoupling of process layer from model layer" design prevents the tool from becoming obsolete when a particular Agent releases a version update, but it also imposes ongoing requirements for compatibility maintenance.

What Real Problems Do These Tools Solve

At the current stage of AI coding tools, the ability to generate code is no longer the bottleneck. What truly troubles developers is: whether the generated code matches intent, whether it has been verified, and whether the review step has been skipped. QualityLayer's value is not in making Agents write better code, but in using process constraints to make Agent output inspectable and traceable.

Turning review from "looking at the diff after the fact" into "approving the plan beforehand," and turning self-checks into independent Agent cross-verification—these two points target the weak links in current AI coding workflows. Of course, a seven-step workflow also means more interaction steps, and for small, simple changes, this process may seem heavy. It is better suited to code changes with a certain level of complexity that need to be taken seriously.

A result of 74 votes and #19 on Product Hunt shows it has resonated with some developers, but the sample size is small. Whether this direction will be more widely accepted depends on whether developers are willing to take a few extra process steps for quality.

Frequently Asked Questions

Is QualityLayer free? The project is open source on GitHub, and you use your own coding Agent subscription with no additional model costs.

Which coding Agents are supported? Claude Code, Codex, Cursor, and four others—seven in total.

Will code be uploaded to the cloud? No, the tool runs on your own computer.

One-line Summary

QualityLayer uses a seven-step workflow to constrain AI coding Agents, modifying code only after plan approval and conducting cross-review by an independent Agent.

Paragraph Summary

QualityLayer is an open-source tool designed to solve the problem that AI coding assistants "can generate code but make quality hard to confirm." It breaks a single code change into seven steps—Discuss, Research, Plan, Outline, Implement, Verify, and Review. Its core mechanisms are plan-approval-first—the Agent can modify code only after the user approves the Plan—and independent Agent review—after implementation, a new Agent that did not participate in coding verifies the result against the original requirements. The tool builds using a test-first approach, supports seven coding Agents including Claude Code, Codex, and Cursor, uses users' own subscriptions, and runs locally. It is better suited to code changes with a certain level of complexity; simple changes may find the process heavy.