# Implement

> 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.

- Skill: `fr-e-d/implement` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add fr-e-d/implement`
- Raw SKILL.md: https://api.skillmd.com/api/skills/fr-e-d/implement/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: ELv2
- Author: Fr-e-d (https://skillmd.com/u/fr-e-d)
- Updated: 2026-09-10
- Page: https://skillmd.com/skills/fr-e-d/implement

---


# 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."**