/codd-assemble

name: codd-assemble
description: |
  Assemble generated CoDD sprint fragments into a complete, buildable project. Use after all `codd implement` sprints have produced `src/generated/sprint_N/` fragments and the design documents are ready to be integrated into final project files, entry points, source code, and configuration.

CoDD Assemble

Assemble generated sprint fragments into a complete, buildable project. This is the final step in the greenfield pipeline after `codd implement`.

Usage

Use this skill after all sprints have been generated via `codd implement`. The assembler reads design documents and generated code fragments, then invokes AI to produce a unified project with all configuration files, entry points, and source code.

Prerequisites

1. `codd implement` has been run for all sprints. 2. Generated fragments exist in `src/generated/sprint_N/` directories. 3. Design documents exist in `docs/` with valid frontmatter.

Workflow

# Basic usage — assembles into src/
codd assemble --path .

# Custom output directory
codd assemble --path . --output-dir app

# Override AI command (e.g., use a different model)
codd assemble --path . --ai-cmd 'claude --print --model claude-opus-4-6 --tools ""'

What It Does

1. Collects all design documents (architecture, component design, state management, etc.) 2. Collects all generated code fragments from `src/generated/sprint_N/` 3. Builds a prompt with both design context and code fragments 4. Invokes AI to produce a unified project:

• **Project configuration**: package.json, tsconfig.json, next.config.*, tailwind.config.*, etc.
• **Entry points**: app/layout.tsx, app/page.tsx, globals.css, etc.
• **Source code**: components, utilities, types, hooks, reducers

5. Parses `=== FILE: path ===` blocks from AI output and writes files

Output

Files are written relative to the project root. The assembler produces both:

• Configuration files at the project root (package.json, tsconfig.json, etc.)
• Source files under the output directory (default: `src/`)

HITL Gate

After assembly, verify the project builds:

# For Node.js/TypeScript projects
npm install
npm run build

# For Python projects
python -m pytest

If the build fails, check:

• Missing imports between assembled files
• Configuration mismatches (TypeScript strict mode, module resolution)
• Framework-specific entry point conventions

Integration in Full Pipeline

#!/bin/bash
set -e

codd init --requirements spec.md
codd plan --init

waves=$(codd plan --waves)
for wave in $(seq 1 $waves); do
  codd generate --wave $wave
done

codd validate

sprints=$(codd plan --sprints)
for sprint in $(seq 1 $sprints); do
  codd implement --sprint $sprint
done

# Final step: assemble fragments into a working project
codd assemble

Troubleshooting

• `No generated fragments found in src/generated/`
• Run `codd implement` first. Fragments are created per sprint.
• Build fails after assembly
• Check that the design documents specify the correct framework and configuration.
• Re-run with `--ai-cmd` pointing to a more capable model (e.g., Opus) for better integration.
• Missing configuration files (package.json, tsconfig.json)
• The assembler prompt explicitly requests these. If missing, re-run assembly.

Guardrails

• Always verify the build after assembly.
• Do not manually edit assembled files before verifying the build — establish a clean baseline first.
• If the assembled output is unsatisfactory, fix the design documents or implementation plan and regenerate, rather than patching assembled code.