Vertical slices and task DAGs: how our Developer agent ships real code

There is a version of AI code generation that everyone has tried: paste a description, receive a wall of code, discover it doesn't compile, doesn't match itself, or quietly does the wrong thing. The failure isn't the model's syntax — modern models write fine code. The failure is that generating code and building software are different activities.

Our Software Developer agent is built around that distinction. It never 'writes the app'. It plans, builds, runs, and verifies — in that order, in small increments, every time.

The developer agent starts from the artifacts the earlier agents produced — the PRD from the product manager, and the data model, API contracts, and architecture from the solution architect. From those it derives a task graph: a directed acyclic graph of work items with explicit dependencies. Schema before repository, repository before endpoint, endpoint before UI.

The DAG matters for two reasons. It forces the agent to understand the build order before touching code, and it gives MAC — and you — a live map of progress: what's done, what's in flight, what's blocked on what.

Instead of building layer by layer (all the models, then all the APIs, then all the UI), the agent builds vertical slices: one thin path of real functionality, end to end, that can be executed. A slice isn't 'the auth module'; it's 'a user can sign up and land on an empty dashboard'.

After each slice, the agent runs the application and verifies the slice actually works — not by re-reading its own code, but by exercising the behavior. Only a verified slice gets committed to the project state, and only then does the DAG advance. If verification fails, the failure stays contained to one small, recent, reviewable change.

This is the same discipline good human teams use, encoded as the agent's only way of working. It's slower per line of code than one giant generation. It is enormously faster per working feature.

The developer agent's output feeds straight into the QA and security agents, and it knows that. Code ships with the tests that prove it, and the pipeline's later stages — generated test suites, black-box audits, security scans — treat the developer's claims as claims, not facts, and check them against the running app.

The result you receive at the end isn't a code dump. It's a repository you own, built in verified increments, with its history, its tests, and its deployment story intact.