go

Files (1)

• SKILL.md

SKILL.md (first lines)

# Go — Build It

**CRITICAL**: Run `HARNESS_DIR=$(epic-harness path)` first. NEVER use `.harness/` in the project directory.

## Execution Modes

This skill has 3 internal modes that run sequentially:

1. **go:plan** — Decompose requirements into ordered, parallelizable tasks
2. **go:build** — Execute each task using TDD (Red→Green→Refactor)
3. **go:integrate** — Merge results, verify all ACs, fix failures

---

## Mode: go:plan (Plan)

Decompose the spec into an execution plan.

### Process

1. **Load the spec:**
   ```bash
   ls -t $HARNESS_DIR/specs/SPEC-*.md | head -1
   ```
   Read the file. Confirm frontmatter has `status: approved`. If not, invoke the **spec** skill first.

2. **Survey the codebase**: Identify relevant files, modules, patterns for each requirement.

3. **Decompose**: Map each Requirement → one or more Tasks. Every task must reference its source requirement:

   ```
   Task 1: [description] — satisfies: R1 — depends on: none — modifies: [file list]
   Task 2: [description] — satisfies: R2 — depends on: Task 1 — modifies: [file list]
   Task 3: [description] — satisfies: R1,R2 (integration) — depends on: Task 1,2 — modifies: [file list]
   ```

4. **Conflict analysis**:
   - Tasks modifying same files → serialize or use worktree isolation
   - Tasks modifying different files → safe to parallelize
   - Don't plan more than 8 tasks — if bigger, split into phases
   - Include "verify integration" as final task if 3+ tasks

5. Show the plan. Get user confirmation (or auto-proceed if in `/orbit`).

6. **Identify risks**: For each task, list potential failure modes:
   ```
   ### Risks
   - {risk}: {mitigation}
   ```

7. **Create feature branch** (standalone invocation only — `/orbit` handles this in Step 3):
   ```bash
   git checkout -b feature/{goal_slug}
   ```

### Execution Order Format

```
- Batch 1 (parallel): Task 1, Task 3
- Batch 2 (sequential): Task 2
```

---

## Mode: go:build (Execute TDD)

For each task, follow this TDD cycle:

### Builder Protocol

1. Read the task description carefully
2. Identify what file(s) to create or modify
3. **Red**: Write the test(s) — confirm they fail
4. **Green**: Write the minimum code to pass
5. **Refactor**: Clean up if needed — no behavior changes
6. Run tests — confirm they pass
7. Report: what was built, what tests pass

### Parallel Execution

Launch sub-agents with these rules:
- `run_in_background: true` for independent tasks (parallel execution)
- `isolation: "worktree"` if and only if parallel tasks modify overlapping files

| Scenario | Parallel? | Same Files? | Isolation? |
|----------|-----------|-------------|------------|
| Task A, B sequential | No | Any | No |
| Task A, B parallel | Yes | No overlap | No |
| Task A, B parallel | Yes | Overlap exists | Yes |

### Subagent Result States

| State | Meaning | Follow-up |
|-------|---------|-----------|
| **DONE** | Task completed, all tests pass | Proceed |
| **DONE_WITH_CONCERNS** | Completed but has warnings | Review. Escalate security/data/breaking issues. |
| **NEEDS_CONTEXT** | Cannot proceed without user input | Prompt user with specific questions |
| **BLOCKED** | Unresolvable error | Try one alternative. If still blocked, report. |

If stuck 3+ times → invoke **agent-introspection** skill.

### Subagent Output Format

```
## Status: [DONE|DONE_WITH_CONCERNS|NEEDS_CONTEXT|BLOCKED]
## Summary: [1-2 sentences]
## Evidence: [test output, file changes]
## Concerns: [only for DONE_WITH_CONCERNS]
## Questions: [only for NEEDS_CONTEXT]
## Blocker: [only for BLOCKED]
```

---

## Mode: go:integrate (Integrate)

After all tasks complete:

1. Categorize each task result by state (DONE/CONCERNS/NEEDS_CONTEXT/BLOCKED)

From epicsagas/epic-harness, Apache-2.0.

More from epicsagas/epic-harness