Capstone — Autonomous Coding Agent (Issue → Tested, HITL-Gated PR)

What you're building

An end-to-end coding agent scoped honestly ('simple bug-fix issues in Python repos <10k LOC with a pytest suite'). It ingests an issue, maps the repo and states its understanding and plan (checkpointed), edits in a git worktree or container (never the real tree), runs the test suite and writes a reproducing test (red → green) iterating up to 5 attempts, and opens a draft PR only after a human approves a view of the diff, test results, and cost. It's instrumented with Module 7 tracing and reports cost per issue.

Suggested weekly plan

1. W21: harness + repo exploration + plan generation working end-to-end on one toy issue.
2. W22: sandboxed editing + test running; first full red→green fix.
3. W23: retry loops, failure handling, HITL PR gate.
4. W24: eval set of 10 issues; run, measure, fix the top failure mode. (Also: full take-home simulation this week.)
5. W25: eval rerun, results write-up, README polish, demo recording.
6. W26: buffer + Gate G4 full mock loop.

# capstone/pipeline.py — glue for the six stages
from langfuse import observe          # tracing from Module 7

@observe()
def solve_issue(issue_url_or_path: str, repo_full: str) -> dict:
    issue = load_issue(issue_url_or_path)        # TODO: GitHub API or local file

    workspace = make_sandbox(repo_full)          # TODO: git worktree OR container
    try:
        plan = explore_and_plan(issue.text)      # checkpointed to plan.json
        outcome = repair(plan, issue.text)       # bounded red->green loop (max 5)

        tests = run_tests()                       # final verification
        diff = git_diff(workspace)               # TODO: git diff in the sandbox
        cost = current_trace_cost()              # TODO: pull from your tracing

        if outcome["status"] == "success" and tests["passed"]:
            url = open_pr_if_approved(            # HITL gate — draft PR only on 'y'
                repo_full, branch=workspace.branch, base="main",
                title=pr_title(issue), body=pr_body(issue, outcome),
                diff=diff, cost_usd=cost,
            )
            return {"issue": issue.id, "result": "pr_proposed", "url": url,
                    "cost_usd": cost}
        return {"issue": issue.id, "result": outcome["status"],
                "cost_usd": cost}
    finally:
        cleanup_sandbox(workspace)               # discard the throwaway tree

# capstone/evaluate.py — run across the issue set, score with the taxonomy
def evaluate(issue_set) -> dict:
    results = []
    for spec in issue_set:                       # TODO: >= 10, real + seeded
        run = solve_issue(spec.url, spec.repo)
        results.append(score_to_taxonomy(run, spec.ground_truth))
    return report(results)                        # success rate + taxonomy + cost/time

Ship it to your portfolio

Hiring managers reportedly look at GitHub before the résumé — for the roles this curriculum targets, this capstone is the résumé. Package it so a reviewer gets the whole story in under five minutes:

• README with a 60-second demo — a GIF or short clip of the full path: issue in → agent explores → red→green tests → HITL approval → draft PR out.
• The PR the agent actually opened — link a real draft PR with the reviewer-ready description, the small focused diff, and CI showing the reproducing test passing.
• Eval results across your issue suite — success rate, the partial-success taxonomy, and median cost/time per issue, straight from your report() output.
• An honest 'Limitations' section — precise scope, named failure modes from the taxonomy, cost envelope, safety boundaries. Reviewers read it first; it's what makes every other claim credible.