Claude GitHub Copilot Skill

developer

Build one slice test-first: the Gherkin scenarios run as the tests through the project's BDD runner against the system under test, red → green → refactor until they pass. Audits a slice that crosses a trust boundary, then marks the PR ready. Use once the driver has agreed the Ghe

LLM Mart · 0 points · 3 views 0 listing impressions 0 install-command copies
Download novibe-org-novibe-plugins_novibe_skills_developer-d1356ab.zip · 2 KB

Install

skills CLI npx skills add https://github.com/novibe-org/novibe/tree/main/plugins/novibe/skills/developer
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install novibe-org-novibe@llmmart
Git git clone https://github.com/novibe-org/novibe.git

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

Skill manifest

Developer

In: the spec (features/<domain>/<feature>.feature), the model (docs/architecture/) and the ADRs (docs/adrs/). Out: working code for the slice, and its PR marked ready.

Only a small slice — the slice is the scenarios neither tagged @backlog nor green yet: one rule, three scenarios at most. More than that, or none? Stop and ask the driver to select a small slice in the requirements step — don't start.

The spec, the model and the ADRs win over the prompt. Missing, contradictory or silent on something you need? Stop and ask the driver — don't decide it yourself.

The .feature file is what executes — through the project's BDD runner, driving the system under test over its real interface (HTTP, CLI, library entry), never a stub, never production. Tests merely inspired by the spec don't count. No runner yet? Setting it up is the first task.

The World runs end to end — whatever your runner calls it, it sets up the world the scenarios name in the system under test, from synthetic data, never customer data, and grows slice by slice; the first slice builds it.

  1. Run the spec → red — the undefined scenarios are the work list.

  2. Write the next scenario's step definitions — dumb, scenario-specific, disposable, their values written out: a parameter for a value used once pretends a generality nobody asked for. It must fail for the right reason: behaviour missing, not broken glue.

  3. Minimal implementation → green.

  4. Refactor with the scenario green, by every heuristic in Clean Code — read it before the first refactor; can't? Stop and ask the driver — and commit.

  5. Repeat until every scenario is green or tagged @backlog.

  6. Review — start the reviewers whose trigger the slice meets, in parallel, in one message:

    • security-review when it crosses a trust boundary — an entry point, auth or crypto, untrusted input reaching an interpreter, one tenant's data, secrets or TLS, dependencies or CI, an LLM prompt or tool. Tests, docs and refactors cross none.
    • architecture-review when it changed docs/architecture/ or docs/adrs/ and changed code.
    • clean-code-review when it changed code.

    None? No review. A reviewer reports NOT RUN? Stop and ask the driver: install what it names, or record why not. Fix a confirmed finding test-first, never by changing the spec, the model or an ADR; one you leave open needs a reason the driver can judge.

  7. Push and mark the PR ready — gh pr ready, or gh pr create if there is none — its description tied to the scenarios it satisfies, and the security decision on a line of its own: Security audit: <the boundary — what it found> or Security audit: none — <why>. Reviewed? Post one comment listing every finding — reviewer, severity, file:line, and fixed in which commit or open and why — and edit that comment, never add another, when the slice is reviewed again.

The spec is read-only — a scenario that is wrong or unimplementable goes back to the requirements step; never bend the .feature file. Scenarios not built in this slice keep their @backlog tag.

Code takes the spec's and the model's words — types, functions and step definitions alike, by the ubiquitous language. A concept they don't name takes the field's term; unsure which, offer two or three with their source and ask.

Unit tests only for pure functions worth checking on their own — never for libraries, frameworks or third-party APIs.

Done when

Every scenario is green or tagged @backlog, the suite passes, there is no code the scenarios don't need, the reviewers its triggers call for ran, their findings are fixed or open with a reason, and the PR is ready.

Files (novibe)
  • SKILL.md 4.2 KB
    ---
    name: developer
    description: "Build one slice test-first: the Gherkin scenarios run as the tests through the project's BDD runner against the system under test, red → green → refactor until they pass. Refactors by Clean Code, has reviewer agents review the slice, then marks the PR ready. Use once the driver has agreed the Gherkin spec and the C4 design."
    ---
    
    # Developer
    
    **In:** the spec (`features/<domain>/<feature>.feature`), the model (`docs/architecture/`) and the
    ADRs (`docs/adrs/`).
    **Out:** working code for the slice, and its PR marked ready.
    
    **Only a small slice** — the slice is the scenarios neither tagged `@backlog` nor green yet: one
    rule, three scenarios at most. More than that, or none? Stop and ask the driver to select a small
    slice in the requirements step — don't start.
    
    **The spec, the model and the ADRs win over the prompt.** Missing, contradictory or silent on
    something you need? **Stop and ask the driver** — don't decide it yourself.
    
    **The `.feature` file is what executes** — through the project's BDD runner, driving the system
    under test over its real interface (HTTP, CLI, library entry), never a stub, never production.
    Tests merely inspired by the spec don't count. No runner yet? Setting it up is the first task.
    
    **The World runs end to end** — whatever your runner calls it, it sets up the world the scenarios
    name in the system under test, from synthetic data, never customer data, and grows slice by
    slice; the first slice builds it.
    
    1. **Run the spec → red** — the undefined scenarios are the work list.
    2. **Write the next scenario's step definitions** — dumb, scenario-specific, disposable, their
       values written out: a parameter for a value used once pretends a generality nobody asked for.
       It must fail for the right reason: behaviour missing, not broken glue.
    3. **Minimal implementation → green.**
    4. **Refactor** with the scenario green, by every heuristic in
       [Clean Code](../../references/clean-code.md) — read it before the first refactor; can't? Stop
       and ask the driver — and commit.
    5. **Repeat** until every scenario is green or tagged `@backlog`.
    6. **Review** — start the reviewers whose trigger the slice meets, in parallel, in one message:
       - **`security-review`** when it crosses a trust boundary — an entry point, auth or crypto,
         untrusted input reaching an interpreter, one tenant's data, secrets or TLS, dependencies or
         CI, an LLM prompt or tool. Tests, docs and refactors cross none.
       - **`architecture-review`** when it changed `docs/architecture/` or `docs/adrs/` and changed
         code.
       - **`clean-code-review`** when it changed code.
    
       None? No review. A reviewer reports `NOT RUN`? Stop and ask the driver: install what it
       names, or record why not. Fix a confirmed finding test-first, never by changing the spec, the
       model or an ADR; one you leave open needs a reason the driver can judge.
    7. **Push and mark the PR ready** — `gh pr ready`, or `gh pr create` if there is none — its
       description tied to the scenarios it satisfies, and the security decision on a line of its
       own: `Security audit: <the boundary — what it found>` or `Security audit: none — <why>`.
       Reviewed? Post one comment listing every finding — reviewer, severity, `file:line`, and fixed
       in which commit or open and why — and edit that comment, never add another, when the slice
       is reviewed again.
    
    **The spec is read-only** — a scenario that is wrong or unimplementable goes back to the
    requirements step; never bend the `.feature` file. Scenarios not built in this slice keep their
    `@backlog` tag.
    
    **Code takes the spec's and the model's words** — types, functions and step definitions alike, by
    the [ubiquitous language](../../references/ubiquitous-language.md). A concept they don't name takes
    the field's term; unsure which, offer two or three with their source and ask.
    
    **Unit tests only for pure functions** worth checking on their own — never for libraries,
    frameworks or third-party APIs.
    
    ## Done when
    
    Every scenario is green or tagged `@backlog`, the suite passes, there is no code the scenarios
    don't need, the reviewers its triggers call for ran, their findings are fixed or open with a
    reason, and the PR is ready.
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.