Implement

---
name: implement
description: Generate correct, minimal, maintainable code that satisfies a validated Story's acceptance criteria against an execution plan. Activate when a Story is validated, a plan exists, and all prerequisites are unambiguous.
license: ELv2
compatibility: Works with any filesystem-based AI coding agent
metadata:
  author: gaai-framework
  version: "1.0"
  category: delivery
  track: delivery
  id: SKILL-IMPLEMENT-001
  updated_at: 2026-02-26
  status: stable
inputs:
  - contexts/artefacts/stories/**  (validated)
  - contexts/artefacts/plans/**
  - contexts/rules/**
  - memory_context_bundle
outputs:
  - code_changes
  - test_artifacts
  - implementation_report
---

# Implementation

## Purpose / When to Activate

Activate when:
- A Story is validated for implementation
- An execution plan exists decomposing the Story into actionable steps
- Relevant memory, rules, and constraints are available

Only proceed when all prerequisites are present and unambiguous.

---

## Process

1. **Load context** — retrieve minimal memory, load applicable rules and constraints

1a. **Check contracted skills from the plan** — If the execution plan contains a contracted
    skill step (from `required_skills`):
    - The platform delivery skills (implement, qa-review, etc.) remain authoritative and are
      not replaced or overridden.
    - Invoke the contracted skill step as specified in the plan, on top of the platform
      backbone.
    - Record in the implementation report which contracted skill was invoked and which bound
      output AC it targets.
    - If the plan contains no contracted skill step (because `required_skills` was
      empty/absent), do NOT introduce any custom skill. The implementation proceeds on the
      platform backbone only.

    **Out-of-contract guard (hard, no exceptions):** IMPL MUST NOT introduce, discover, or
    invoke any custom skill that was not contracted in the story's `required_skills` and
    emitted as an explicit step in the plan. Introducing an out-of-contract custom skill is a
    scope violation — QA will FAIL it.

2. **Interpret acceptance criteria** — translate into specific expected behaviors, validate against plan
3. **Map plan to implementation** — determine file paths, naming, modules per conventions; clarify dependency edges
4. **Generate code** — write code per plan steps, annotate links to acceptance criteria, respect all style/architecture/quality rules
5. **Generate tests** — cover expected behavior from acceptance criteria, include required edge cases, ensure automatable
6. **Internal validation** — verify acceptance criteria map to code/tests, run linting if required by rules, confirm memory constraints respected
7. **Produce delivery outputs** — code changes, test artifacts, implementation report

---

## Output Definitions

**`code_changes`** — diffs or code fragments structured for integration

**`test_artifacts`** — test files (unit/integration) aligned with acceptance criteria

**`implementation_report`** — human-readable summary including:
- Mapping to plan steps
- Rules applied
- Memory constraints referenced
- Known risks and decisions

---

## Quality Checks

- All acceptance criteria are met
- All rule checks pass
- Relevant tests exist and are runnable
- Implementation report articulates decisions
- Scope is unchanged
- Error-prone operations (I/O, parsing, external calls) have explicit error handling — failures are surfaced, not silently swallowed
- Functions exposed to external input validate arguments before executing
- Identifiers are explicit and intention-revealing — no single-letter variables, no ambiguous abbreviations outside established conventions
- Each function or module has a single, clear responsibility — if it does more than one thing, it must be decomposed

---

## Non-Goals

This skill must NOT:
- Redefine product intent
- Add unrequested features
- Bypass governance rules
- Guess missing requirements
- Embed hidden context or implicit assumptions
- Introduce, discover, or invoke any custom skill not contracted via `required_skills` and emitted as an explicit step in the execution plan

**"I implement exactly what the plan defines, and I prove it."**