Claude opencode Skill

implement

Execute one bounded RED to GREEN experiment from bead or caller intent; return derived subject identity and check facts. Triggers: "implement", "implement this bead", "run the experiment". Full plan-to-validation requests route to rpi.

LLM Mart · 0 points · 9 views 0 listing impressions 0 install-command copies
Download boshu2-agentops-skills_implement-596942d.zip · 16 KB

Install

skills CLI npx skills add https://github.com/boshu2/agentops/tree/main/skills/implement
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install boshu2-agentops@llmmart
Git git clone https://github.com/boshu2/agentops.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole boshu2/agentops collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Implement

Implement the accepted outcome. Repair ordinary known defects directly. Use the existing intent; a clear edit needs no Plan first. An incoming report nobody has accepted yet goes to Triage first. Implement owns source changes and factual checks.

Rules that decide the result

  • Fix the cause, not the oracle. Never loosen an assertion, tolerance, golden, fixture or suppression, or substitute a mock or placeholder, to turn a check green; nor change what the check runs against: code that acts differently under test or CI, a newly silenced failure path, or a check made non-blocking or skipped. A check that fails against accepted behavior points at a product defect; changing what the check accepts is an acceptance change and needs caller authority.
  • Find live consumers before editing. Search the callers, readers, scripts, docs and tests of every edited function, type, path, format or message. For each one, state whether the change affects it and which check covers it. When retiring or renaming, consumers include installations, lookups and old-name invocations; preserve historical provenance. If the replaced interface never merged or shipped and every consumer update fits the scope, update them and delete the old version in the same change, with no alias or shim; otherwise keep the old version working or report it.
  • Name discriminating checks. A behavioral change preserves RED for the expected missing behavior: name the check that fails before the edit and passes after (Test's proof rule), plus the check for each affected consumer.
  • Report only what ran. Give exact commands and results. List every check you did not or could not run as not run. Never call unrun work verified, fixed or green. Output can show as soon as a command runs, so keep secrets out when you build it: credentials stay in the environment, output that may carry tokens goes to a file, and only redacted excerpts are shown.

When changing a public failure path, preserve its native failure signal and check that its recovery advice matches any work already performed. For uncertain write outcomes or unattended callers, use only the relevant checks in Test's error recovery method.

For an accepted bounded shortcut, review feedback or a defect your change introduced, an authorized commit, history rewrite or merge conflict, dependency upgrade, removal, blocked operation, a decision read from another tool's state or your own uncertain write, use only the matching change safety method. These methods preserve existing authority; they grant no new operation.

For authorized service operations, load only the relevant procedure from operations methods (reliability, delivery, incident recovery, resilience, toil); ordinary edits owe no operations phase.

Workflow

  1. Read intent, acceptance, scope and repository boundaries before the first write; reuse loaded contracts. RPI boundaries apply when RPI is selected; caller-selected episode tracking follows the session association reference. Note the revision and files already modified, staged or untracked; report only your own as changed, and ask the caller before editing one holding others' edits.
  2. Carry the accepted behavior examples forward unchanged. Use repository domain names in symbols and tests; check observable outcomes through the relevant interface. Run the smallest applicable check before and after editing. Pure refactors, relocations or docs may have an honest green baseline. Prefer existing tests or small discriminating probes.
  3. Make the smallest in-scope change. When repairing discovery or checks, preserve the consumer's existing input selection; fixing an error path does not authorize a wider scan. Use a negative control when exclusion matters. Check a representative change against existing constraints before bulk propagation, and the authored source set before broad regeneration. A scripted edit across files first confirms that each anchor matches exactly once; on zero or several matches, write nothing and re-derive it. Repair known failures directly and verify the exact result with a check; a repair does not start another review. A disproved assumption may change the approach within scope; use Plan only for consequential uncertainty.
  4. Read the repository's actual check recipe, including instrumentation and environment, rather than reconstructing it from memory. Run targeted tests and lint/static checks before broad integration, and required full checks at integration. Reuse exact-input receipts only while source, tool and relevant environment match. Neither bypass required hooks nor replay a check just to rename its receipt. A required CI job's known failure is actionable before the run ends: repair it within scope, keep the failed subject's evidence and rerun affected checks. Pending jobs do not imply success. A new check, hook or lint rule counts once the aggregate command or CI runs it (a Git hook needs an install path; .git/hooks is not cloned) and it fails on a deliberate violation; else list it under gaps as not wired. Use a local server already on a port only if it provably serves this checkout; stop only processes you started.
  5. Refactor while acceptance remains green. Inspect changed tests, fixtures, goldens, tolerances, suppressions and specification text against original intent before handoff. Reread that intent at its source, not a compacted summary, and check the whole delta against it, untracked files included. Remove leftovers of abandoned approaches, temporary probes (one shared marker lets a single search prove none remain) and files your checks made; list any path you cannot explain under gaps as a scope amendment.
  6. Have the runtime derive actual changed paths and content identity: read changed paths from Git (git status --porcelain, git diff --name-only <base>), never from memory; ao provenance manifest --root <repo> with one --include <path> per declared path digests only the paths you declare and runs no Git. A delegated increment awaiting integration returns an exact commit or runtime-derived content digests, author context ID and check facts in the existing handoff. Copy that ID from the session, subagent or thread ID the runtime exposes, or label a caller-supplied one as supplied; otherwise report it as unknown, never made up. The integrating caller derives subject-manifest.v1 (AgentOps schema subject-manifest.v1.schema.json, AgentOps source checkout only) over the complete final subject before judgment; an independently judged increment needs its own manifest. Do not generate both merely because work was delegated. Where the repository records AgentOps evidence bindings, also run the advisory ao provenance evidence-orphans --root <repo-root> with one --changed <path> per derived path. Disclose the rows whose cause is changed_path or both (they bind your paths); count the rest under gaps as pre-existing drift, and refresh a binding only when its owner asks. Without ao, list it under not run.
  7. Return the handoff below.

Handoff

Keep full logs at their source; do not duplicate inventories or status documents.

changed:        <runtime-derived paths>; identity: <commit or content digests>
author:         <runtime session/subagent/thread ID, "ID (supplied)" or "unknown">; when an integrator or fresh read follows
checks:         <exact command> -> <result>, one per line; before and after for a behavioral change
not run:        <check> -> <reason>; "none" only when every relevant check ran
consumers:      <file:line> -> <covering check, or "uncovered">
not_as_briefed: <steps refused, held, worked around or unverified, one line with its reason each> | none
gaps:           <missing or truncated evidence, known failures, scope amendments needed> | none
cause:          <defect repairs only: trigger -> mechanism -> symptom at file:line; sites left as follow-up>

Report an uncovered live consumer for a caller scope amendment and continue independent authorized work. Disclose a reversible implementation choice only when its alternative has a material consequence the caller may want to change; name the choice, alternative and reason in the handoff, without a fixed worksheet. Generated companions already included as scope require no new approval; a change to accepted direction, behavior or acceptance always needs caller authority.

Diagnosis, scaffolding and delegated work

Before repairing a failure you cannot yet explain, read and follow the diagnosis loop. The same file holds the experiments for races, leaked state, hangs, regressions and failures that cross components.

When scaffolding is the requested change, start from the repository's existing layout (or the ecosystem's standard one for a new project) and one working vertical slice; avoid placeholder success paths and a new framework for a one-off operation.

Prefer current-session execution. When delegation is authorized, or the caller asks for a one-shot adapter or a factory, read delegated work before dispatching or writing it.

Finish

Specialists advise only; known defects stay implementation work. A genuine causal stall admits one bounded fresh helper under RPI's stall rule; retries renew no bound.

Return facts, not semantic PASS. An implement-only handoff does not authorize Git, tracker or delivery transitions; existing caller authority remains usable. A full outcome request finishes on its checks and CI; it continues to one fresh independent judgment only on Validate's triggers.

Files (agentops)
  • references
    • change-safety.md 7.7 KB
      Loading…
    • delegated-work.md 1.4 KB
      Loading…
    • difficult-failures.md 9.9 KB
      Loading…
    • operations.md 7.8 KB
      Loading…
  • SKILL.md 11 KB
    ---
    name: implement
    description: 'Make the code change a ticket or bug report asks for, then prove it with the repo''s own checks. Use when: told to fix, change or build something, such as "fix this bug".'
    practices:
    - tdd
    - refactoring
    - small-batch-flow
    hexagonal_role: driving-adapter
    consumes: []
    produces:
    - subject-manifest.v1
    output_contract: 'content identity, author context ID and check facts through the native handoff; subject-manifest.v1 at the judgment boundary'
    context_rel:
    - kind: customer-of
      with: plan
    skill_api_version: 1
    user-invocable: true
    metadata:
      graph_root: true
      tier: execution
      dependencies: []
      capabilities: [execute_one_experiment, collect_factual_evidence]
      effects: [modify_declared_subject, derive_subject_manifest]
      canonical_status: canonical
      disposition: keep
      triggers: ["execute the next wave", "per-lane evidence", "fix this bug", "CI is red", "loosen the assertion"]
    ---
    
    # Implement
    
    Implement the accepted outcome. Repair ordinary known defects directly. Use the
    existing intent; a clear edit needs no Plan first. An incoming report nobody
    has accepted yet goes to [Triage](../triage/SKILL.md) first. Implement owns source changes
    and factual checks.
    
    ## Rules that decide the result
    
    - **Fix the cause, not the oracle.** Never loosen an assertion, tolerance,
      golden, fixture or suppression, or substitute a mock or placeholder, to turn
      a check green; nor change what the check runs against: code that acts
      differently under test or CI, a newly silenced failure path, or a check made
      non-blocking or skipped. A check that fails against accepted behavior points
      at a product defect; changing what the check accepts is an acceptance change
      and needs caller authority.
    - **Find live consumers before editing.** Search the callers, readers, scripts,
      docs and tests of every edited function, type, path, format or message. For
      each one, state whether the change affects it and which check covers it. When
      retiring or renaming, consumers include installations, lookups and old-name
      invocations; preserve historical provenance. If the replaced interface never
      merged or shipped and every consumer update fits the scope, update them and
      delete the old version in the same change, with no alias or shim; otherwise
      keep the old version working or report it.
    - **Name discriminating checks.** A behavioral change preserves RED
      for the expected missing behavior: name the check that fails before the edit
      and passes after ([Test's proof rule](../test/SKILL.md#critical-constraints)),
      plus the check for each affected consumer.
    - **Report only what ran.** Give exact commands and results. List every check
      you did not or could not run as not run. Never call unrun work verified,
      fixed or green. Output can show as soon as a command runs, so keep secrets
      out when you build it: credentials stay in the environment, output that may
      carry tokens goes to a file, and only redacted excerpts are shown.
    
    When changing a public failure path, preserve its native failure signal and
    check that its recovery advice matches any work already performed. For uncertain
    write outcomes or unattended callers, use only the relevant checks in
    [Test's error recovery method](../test/references/error-recovery.md).
    
    For an accepted bounded shortcut, review feedback or a defect your change
    introduced, an authorized commit, history rewrite or merge conflict, dependency
    upgrade, removal, blocked operation, a decision read from another tool's state
    or your own uncertain write, use only the matching [change safety method](references/change-safety.md).
    These methods preserve existing authority; they grant no new operation.
    
    For authorized service operations, load only the relevant procedure from
    [operations methods](references/operations.md) (reliability, delivery, incident
    recovery, resilience, toil); ordinary edits owe no operations phase.
    
    ## Workflow
    
    1. Read intent, acceptance, scope and repository boundaries before the first
       write; reuse loaded contracts. [RPI boundaries](../rpi/references/boundaries.md)
       apply when RPI is selected; caller-selected episode tracking follows the
       [session association reference](../orchestrate/references/session-associations.md#work-to-session-associations).
       Note the revision and files already modified, staged or untracked; report
       only your own as changed, and ask the caller before editing one holding
       others' edits.
    2. Carry the accepted behavior examples forward unchanged. Use repository
       domain names in symbols and tests; check observable outcomes through the
       relevant interface. Run the smallest applicable check before and after
       editing. Pure refactors, relocations or docs may have an honest green
       baseline. Prefer existing tests or small discriminating probes.
    3. Make the smallest in-scope change. When repairing discovery or checks,
       preserve the consumer's existing input selection; fixing an error path does
       not authorize a wider scan. Use a negative control when exclusion matters.
       Check a representative change against existing constraints before bulk
       propagation, and the authored source set before broad regeneration. A
       scripted edit across files first confirms that each anchor matches exactly
       once; on zero or several matches, write nothing and re-derive it. Repair
       known failures directly and verify the exact result with a check; a repair
       does not start another review. A disproved assumption may change the
       approach within scope; use Plan only for consequential uncertainty.
    4. Read the repository's actual check recipe, including instrumentation and
       environment, rather than reconstructing it from memory. Run targeted tests
       and lint/static checks before broad integration, and required full checks at
       integration. Reuse exact-input receipts only while source, tool and relevant
       environment match. Neither bypass required hooks nor replay a check just to
       rename its receipt. A required CI job's known failure is actionable before
       the run ends: repair it within scope, keep the failed subject's evidence and
       rerun affected checks. Pending jobs do not imply success. A new check, hook
       or lint rule counts once the aggregate command or CI runs it (a Git hook needs
       an install path; `.git/hooks` is not cloned) and it fails on a deliberate
       violation; else list it under `gaps` as not wired. Use a local server already
       on a port only if it provably serves this checkout; stop only processes you started.
    5. Refactor while acceptance remains green. Inspect changed tests, fixtures,
       goldens, tolerances, suppressions and specification text against original
       intent before handoff. Reread that intent at its source, not a compacted
       summary, and check the whole delta against it, untracked files included.
       Remove leftovers of abandoned approaches, temporary probes (one shared
       marker lets a single search prove none remain) and files your checks made;
       list any path you cannot explain under `gaps` as a scope amendment.
    6. Have the runtime derive actual changed paths and content identity: read
       changed paths from Git (`git status --porcelain`,
       `git diff --name-only <base>`), never from memory;
       `ao provenance manifest --root <repo>` with one `--include <path>` per
       declared path digests only the paths you declare and runs no Git. A delegated
       increment awaiting integration returns an exact commit or runtime-derived
       content digests, author context ID and check facts in the existing handoff.
       Copy that ID from the session, subagent or thread ID the runtime exposes, or
       label a caller-supplied one as supplied; otherwise report it as unknown,
       never made up. The integrating caller derives `subject-manifest.v1` (AgentOps
       schema [subject-manifest.v1.schema.json](https://github.com/boshu2/agentops/blob/main/schemas/subject-manifest.v1.schema.json), AgentOps source checkout only) over the complete final
       subject before judgment; an independently judged increment needs its own
       manifest. Do not generate both merely because work was delegated. Where the
       repository records AgentOps evidence bindings, also run the advisory
       `ao provenance evidence-orphans --root <repo-root>` with one `--changed <path>`
       per derived path. Disclose the rows whose cause is `changed_path` or `both`
       (they bind your paths); count the rest under `gaps` as pre-existing drift,
       and refresh a binding only when its owner asks. Without `ao`, list it under
       `not run`.
    7. Return the handoff below.
    
    ## Handoff
    
    Keep full logs at their source; do not duplicate inventories or status documents.
    
    ```text
    changed:        <runtime-derived paths>; identity: <commit or content digests>
    author:         <runtime session/subagent/thread ID, "ID (supplied)" or "unknown">; when an integrator or fresh read follows
    checks:         <exact command> -> <result>, one per line; before and after for a behavioral change
    not run:        <check> -> <reason>; "none" only when every relevant check ran
    consumers:      <file:line> -> <covering check, or "uncovered">
    not_as_briefed: <steps refused, held, worked around or unverified, one line with its reason each> | none
    gaps:           <missing or truncated evidence, known failures, scope amendments needed> | none
    cause:          <defect repairs only: trigger -> mechanism -> symptom at file:line; sites left as follow-up>
    ```
    
    Report an uncovered live consumer for a caller scope amendment and continue
    independent authorized work. Disclose a reversible implementation choice only
    when its alternative has a material consequence the caller may want to change;
    name the choice, alternative and reason in the handoff, without a fixed worksheet.
    Generated companions already included as scope require no new approval; a change
    to accepted direction, behavior or acceptance always needs caller authority.
    
    ## Diagnosis, scaffolding and delegated work
    
    Before repairing a failure you cannot yet explain, read and follow the
    [diagnosis loop](references/difficult-failures.md#diagnosis-loop). The same
    file holds the experiments for races, leaked state, hangs, regressions and
    failures that cross components.
    
    When scaffolding is the requested change, start from the repository's existing
    layout (or the ecosystem's standard one for a new project) and one working
    vertical slice; avoid placeholder success paths and a new framework for a
    one-off operation.
    
    Prefer current-session execution. When delegation is authorized, or the caller
    asks for a one-shot adapter or a factory, read
    [delegated work](references/delegated-work.md) before dispatching or writing it.
    
    ## Finish
    
    Specialists advise only; known defects stay implementation work. A genuine
    causal stall admits one bounded fresh helper under RPI's
    [stall rule](../rpi/SKILL.md#causal-stall-and-bounds); retries renew no bound.
    
    Return facts, not semantic PASS. An implement-only handoff does not authorize
    Git, tracker or delivery transitions; existing caller authority remains usable.
    A full outcome request finishes on its checks and CI; it continues to one fresh
    independent judgment only on [Validate's triggers](../validate/SKILL.md#when-a-fresh-judgment-is-worth-it).
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.