Coder

Implement code changes for a task. Use when given a task to implement, bug to fix, or feature to build.

Required Companion Skills

Before coding, also load:

• test-driven-development
• verification-before-completion

Process

1. Understand - Read the task requirements carefully
2. Explore - Use read_file and run_bash to understand existing code
3. Plan - Identify what files need to change
4. Implement - Make minimal, focused changes
5. Verify - Run bild <namespace> to confirm compilation
6. Fix - If build fails, fix errors and re-verify
7. Capture evidence - Produce a mini proof-of-work artifact before handoff

Guidelines

• Make the smallest change that solves the problem
• Follow existing code patterns and conventions
• Don’t refactor unrelated code
• Don’t add features not requested
• Always verify compilation before finishing

Verification

Fast feedback loop - Use typecheck before full build:

# Quick type check (seconds, not minutes)
typecheck.sh <file>

# Full build (after types pass)
bild <namespace>

# With tests
bild --test <namespace>

If it fails, fix the errors. Do not declare success until it compiles.

Safe Refactoring

When replacing code (e.g., rewriting in different language):

1. Write new code first - don’t delete anything yet
2. Verify new code passes - typecheck.sh then bild
3. Only then delete old code - after new code is proven working
4. Commit checkpoint - if refactor is large, commit working intermediate state

Never delete old code before new code passes all checks.

Example - replacing TypeScript with Python:

# 1. Write new Python file
edit_file NewServer.py ...

# 2. Verify it builds
typecheck.sh NewServer.py
bild Omni/Path/NewServer.py

# 3. Only after success, delete old TS
run_bash rm -rf old-ts-directory/

Common Patterns

Haskell

• Check existing imports for patterns
• Use Text not String (unless interfacing with legacy code)
• Add type signatures to all top-level definitions
• Use qualified imports: import qualified Data.Text as Text

Python

• Use import X as Y pattern (not from X import Y) - required by bild
• Add type hints to function signatures
• Use # : dep <package> comments for dependencies

Evidence Artifact (Showboat-style)

Before declaring implementation complete, create a short, structured proof-of-work artifact that shows what actually happened.

Required sections:

• Scope - task id, namespace, and files changed
• Commands run - exact verification/build/test commands
• Results - key output snippets (pass/fail, artifact paths, notable warnings)
• Checks performed - what behavior was manually/automatically validated
• Open issues - anything incomplete, flaky, or needing follow-up

Preferred format and location:

• Commit a markdown artifact in _/tmp/proof-<task-id>.md while working
• Before handoff, either:
  • move a cleaned version into a durable location committed with the code, or
  • paste the artifact (or concise equivalent) as a task comment

Minimum quality bar:

• Evidence must be specific enough that another person can replay verification
• Do not claim success without command evidence
• If verification fails, include the failure and next step instead of hiding it

Task Handoff

If this work is tied to a task item:

• move task to review when coding + evidence are done:

task update <task-id> review --json

Do NOT mark it done after coding; done is for human verification.

Output

When done, summarize:

• What files were changed
• What the changes do
• Any concerns or follow-up work needed

Do NOT commit - a reviewer will handle that.