agentleFS
prygrnprygrn/agent-kernel/skills/implementer/SKILL.md

implementer

Skill0 starsChanged 3 months agoMITView on GitHub

Use this role when the agent must write source code and its tests to satisfy a feature's reference — its contract when one exists, otherwise the task description — strictly within an assigned scope, without altering the contract or specs.

11 other projects use a version of this.

Adopted by

Most recently taken up by

The file

We split this skill into the rules it gives an agent

6 rules. 0 are common, 4 are distinctive, and 2 are very specific to this project.

  • 0

    Common

    Most of the 11 edited versions we read keep these.

  • 4

    Distinctive

    This author's own choices. Worth a look.

  • 2

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Read the feature contract when one exists, otherwise the task description in the review, before writing any code.

    line 31
  2. Very specific:

    Write the tests first, commit them failing in a test commit, then make them pass.

    line 34
  3. Distinctive:

    When lots run in parallel, honor any shared return type or interface signature the contract freezes, exactly.

    line 39
  4. Distinctive:

    Verify every external dependency (API, library, module, crate) against its real source, never from memory.

    line 42
  5. Distinctive:

    Never write to the feature contract or specs.

    line 47
  6. Very specific:

    Never decide an undecided product or architecture question found in the spec or journal.

    line 52

“Common” is measured: kept by at least 6 in 10 of the 11 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Implementer

PRODUCES:       source code and tests satisfying the feature's reference, within the
                 assigned scope
NEVER PRODUCES: feature contract changes, spec changes, review verdicts, QA verdicts,
                 changes outside the assigned scope
DEPENDS ON:     rules/always/methodology.md (contract or task description as the
                 reference; normative hierarchy; W-on-specs-forbidden;
                 read-before-acting; flag-undecided-questions; verify external
                 dependencies against their real source)
                 rules/always/testing.md (failing test committed before the code)
                 rules/always/conventions.md (cross-cutting and naming conventions)
                 rules/always/git.md (commit format; agent opens the review, human merges)
PERMISSIONS:
  source code      : W        # within the assigned scope only
  tests            : W        # within the assigned scope only
  feature contract : R
  specs            : R
  journal          : W        # when one exists: logs non-trivial technical decisions
  review           : W

Operating

  • Read the feature contract when one exists, otherwise the task description in the review, before writing any code. It is the objective to satisfy, not something to renegotiate.
  • Write the tests first, commit them failing in a test commit, then make them pass. Once committed, they are not adjusted to fit the code.
  • Stay strictly within the assigned scope. Edit only the files the task names; do not touch integration points, orchestrators, or sibling modules that another lot owns — their integration happens separately after parallel lots are merged.
  • When lots run in parallel, honor any shared return type or interface signature the contract freezes, exactly. Sibling lots depend on it; a divergence here is a semantic conflict that a clean git merge will not catch.
  • Verify every external dependency (API, library, module, crate) against its real source, never from memory.

Boundary

  • Never write to the feature contract or specs. If the contract appears wrong or unsatisfiable, stop and flag it rather than editing it — the code changes, never the contract.
  • The same holds for committed tests: if one appears wrong, flag it for the human instead of weakening it.
  • Never decide an undecided product or architecture question found in the spec or journal; flag it for the human and keep going on what is decided (per always/methodology.md).

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.