New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Implement

by BlackBeltTechnology in BlackBeltTechnology/pi-agent-dashboard

Disciplined implementation in pi-agent-dashboard: the rebuild matrix (extension→reload, server→restart, client→build+restart, openspec-apply→full rebuild) plus the project's code discipline rules.

MITAuto-check passedTesting & QA

Install Implement

skills CLI
$ npx skills add BlackBeltTechnology/pi-agent-dashboard --skill implement -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install BlackBeltTechnology/pi-agent-dashboard implement --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/BlackBeltTechnology/pi-agent-dashboard.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.pi/skills/implement .claude/skills/implement && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
implement
GitHub stars
315
Token cost
~2k tokens
SKILL.md length
804 words
Files
16 (incl. scripts, references)
Skills in repo
66
Repo updated
First seen
Licence
MIT

At a glance

Disciplined implementation in pi-agent-dashboard: the rebuild matrix (extension→reload, server→restart, client→build+restart, openspec-apply→full rebuild) plus the project's code discipline rules.

  • After editing extension/server/client
  • SKILL.md covers Quick decision tree, Review — two tiers (inner loop…, Subagent checkpoints (apply… and The discipline — write less…, plus 3 more sections
  • Runs TypeScript scripts from its folder; calls npx, npm and git
  • After applying an OpenSpec change

What it does

Implement is an agent skill from BlackBeltTechnology/pi-agent-dashboard. Disciplined implementation in pi-agent-dashboard: the rebuild matrix (extension→reload, server→restart, client→build+restart, openspec-apply→full rebuild) plus the project's code discipline rules. Use when writing code, after editing extension/server/client, after applying an OpenSpec change, when unsure what to rebuild, or before committing. Triggers: "rebuild and restart", "TDD this".

Its SKILL.md is about 2k tokens, which your agent loads only when the skill is triggered. The skill folder holds 17 other files, including scripts and reference files (for example `SKILL.md.AGENTS.md`, `references/code-discipline.md` and `references/code-discipline.md.AGENTS.md`).

It sits in Testing & QA, covering Test-driven development. The repository describes itself as: Real-time web dashboard for pi coding-agent sessions. Multi-session view, live chat mirroring, integrated terminal, diff viewer, pi-flows execution, and mobile-first remote… The licence is MIT.

When your agent uses it

  • After editing extension/server/client
  • After applying an OpenSpec change
  • Unsure what to rebuild
  • Before committing

Example prompts

  • “rebuild and restart”
  • “TDD this”
  • “/implement”

Requirements

  • Node.js
  • Docker

What it can do on your machine

Read from SKILL.md and the folder at commit e23e533. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 10 files in scripts/ (TypeScript), which the agent can run.

    Shell commands in SKILL.md call:

    • npx
    • npm
    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use npx, npm and git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Implement loads about 2k tokens when it runs, and up to ~5.2k if it reads all its reference files. Until then it costs about 100 tokens; SKILL.md has 804 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~100
When it runs · the whole SKILL.md, loaded when a task matches
~2k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~5.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from BlackBeltTechnology/pi-agent-dashboard at commit e23e533, republished under its MIT licence (© BlackBeltTechnology). 804 words, ~2,015 tokens.

Download SKILL.mdSave it as .claude/skills/implement/SKILL.md (or your agent's skills folder). This skill also uses 15 other files; get the full folder from GitHub.
name
implement
description
Disciplined implementation in pi-agent-dashboard: the rebuild matrix (extension→reload, server→restart, client→build+restart, openspec-apply→full rebuild) plus the project's code discipline rules. Use when writing code, after editing extension/server/client, after applying an OpenSpec change, when unsure what to rebuild, or before committing. Triggers: "rebuild and restart", "TDD this".

Implement

Two halves: how to write the change (discipline) and how to land it in the running system (rebuild + restart).

The skill exists because both halves are easy to get wrong:

  • Agents over-engineer simple changes when they're not anchored.
  • Agents rebuild the wrong component (or worse, all components when they didn't need to) after editing files.

Quick decision tree

        Did you edit code?
                │
       ┌────────┴────────┐
       │                 │
       ▼                 ▼
   src/extension/    src/server/ or src/shared/
       │                 │
       ▼                 ▼
   npm run reload    curl -X POST localhost:8000/api/restart
                     (no build step — jiti runs TS directly)

   src/client/ (dev mode)   →  nothing, Vite HMR
   src/client/ (prod mode)  →  npm run build && restart
   Multi-component / openspec  →  npx tsx .pi/skills/implement/scripts/full-rebuild.ts

Quick check current mode:

bash
npx tsx .pi/skills/implement/scripts/check-mode.ts    # prints "dev" or "production"

Restart server (preserves mode unless overridden):

bash
npx tsx .pi/skills/implement/scripts/restart-server.ts          # graceful restart, keeps mode
npx tsx .pi/skills/implement/scripts/restart-server.ts --dev    # force dev mode
npx tsx .pi/skills/implement/scripts/restart-server.ts --prod   # force production mode

Full rebuild (after openspec-apply or multi-component change):

bash
npx tsx .pi/skills/implement/scripts/full-rebuild.ts

full-rebuild.ts deploys the checked-out dev version to the local running instance (build + restart + reload). It is NOT a feature-implementation step — worktree / Docker-isolated feature work does not run it. The code-review gate is separate (below).

Scripts are TypeScript (cross-platform). All invocations use npx tsx so they work identically on Linux, macOS, and Windows. tsx is already a project dep.

Full matrix with edge cases (dev-mode fallback, fault-tolerant restart, single-restart-path rule) lives in references/rebuild-matrix.md.

Review — two tiers (inner loop vs ship gate)

Review is split by moment. The inner loop runs on an unlimited engine every non-trivial change; the rate-limited cloud gate is reserved for the PR.

Inner loop (during dev, before commit) — review-code discipline. After writing a non-trivial change, review the diff with the review-code skill (eng-disciplines): engine-agnostic — inspect design→correctness→complexity→tests→naming→security, emit labelled findings, fix issue(blocking) surgically, re-review until no blocking finding remains, then commit. Runs on a model engine — no cloud quota spent, so run it freely per change.

Ship gate (opt-in, PR-time) — CodeRabbit. Reserved for the pull request so its quota is unspent during dev. Worktree-safe and server-independent — no build, no restart:

bash
RUN_CR_REVIEW=1 npx tsx .pi/skills/implement/scripts/review-changes.ts   # opt in (uncommitted)
npx tsx .pi/skills/implement/scripts/review-changes.ts --ship -t committed --base main
npx tsx .pi/skills/implement/scripts/review-changes.ts                   # default: skips → use review-code

Warn-and-continue, never blocks: CodeRabbit is cloud rate-limited; on limit / missing CLI / auth failure it prints "deferred to a later cycle" and exits 0. Fix Critical/Warning findings, then commit. See the code-review skill for the CodeRabbit severity triage + fix loop.

openspec-apply: the review-code inner-loop pass runs after each task's code is written; the CodeRabbit gate is opt-in at ship (ship-change owns the PR-time review). Both run in the worktree without touching the main server.

Subagent checkpoints (apply loop) — offload read/write-light work, keep the builder inline

The builder (this loop) owns all decisions and code writes — coherence stays in one context. Spawn a subagent (explicit Agent call) only at these signals, to keep the main context sharp:

Signal in the task / diffSpawnWhy isolated
touches auth, secrets, PII, untrusted input, webhooks, or a latency/throughput budgetAuditdeep read-only risk pass → findings; fix inline
contextFiles list is large (many files / big)Exploredistill the spec; else read directly for coherence
a change landed and docs/ prose needs updatingDocScribeRule-6 docs-delegation; caveman-style writes

Review stays a skill (review-code), not a subagent — review+fix is coherence-critical and wants full context. Tests: run+capture inline (tee→grep); root-cause via systematic-debugging inline. Full rationale: docs/skills-as-subagents.md.

Show full SKILL.md (349 more words)Show less

The discipline — write less code, write the right code

The full code-discipline reference lives in references/code-discipline.md. It expands AGENTS.md "Code Instructions" with concrete patterns, anti-patterns, and examples. Headline rules:

RuleOne-liner
0. kb-first, even as an executorBefore you grep/rg for a symbol, Read a file to learn its purpose, or chase an import, run kb_search / kb agents <path> / kb_neighbors FIRST. Fires on the ACTION, not the intent — knowing which file the task names does not exempt you.
1. Think before codingState assumptions. Ask via ask_user when unclear. Never speculate about unread files. Confirm major plans.
2. Simplicity firstMinimum code that solves the problem. No speculative abstractions. "Would a senior engineer say this is overcomplicated?"
3. Surgical changesTouch only what you must. Don't "improve" adjacent code. Match existing style. Every changed line traces to the request.
4. Goal-driven (TDD)Write/update tests first → verify they fail → make them pass. Captures intent before code exists.
5. CommunicationHigh-level summary per change. Use ask_user (not plain text) when you need a choice.

These rules also live in AGENTS.md so they're always in context. This skill loads on implementation triggers so they get foregrounded when the agent is about to write code.

Running tests — tee→grep, never rerun

Never rerun npm test to inspect errors. Pipe once, grep many times:

bash
npm test 2>&1 | tee /tmp/pi-test.log         # run once, capture
grep -nE 'FAIL|Error|✗|✘' /tmp/pi-test.log    # find failures
grep -n -A 20 'FAIL ' /tmp/pi-test.log         # failure + context

For deeper test triage (per-package vitest configs, watch mode, coverage), see the debug-dashboard skill — its references/test-failure-triage.md.

When the running system misbehaves

Implementing != debugging. If the dashboard starts misbehaving (server hung, bridge won't connect, blank page, tests failing for non-obvious reasons), switch to the debug-dashboard skill.

If your change went red in CI after git push, switch to the ci-troubleshoot skill.

  • openspec-new-change — capture a non-trivial change as an OpenSpec proposal first
  • openspec-apply-change — implement tasks from an OpenSpec change with the artifact workflow
  • openspec-verify-change — validate implementation matches artifacts before archiving
  • review-code — inner-loop diff review discipline (unlimited engine), before commit
  • code-review — the opt-in CodeRabbit ship gate (PR-time)
  • debug-dashboard — diagnose a misbehaving running system
  • ci-troubleshoot — diagnose failed CI runs after push
  • release-cut — when the change is ready to ship as a versioned release

© BlackBeltTechnology, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 15 other files (scripts, references) in .pi/skills/implement of BlackBeltTechnology/pi-agent-dashboard.

  • SKILL.md
  • SKILL.md.AGENTS.md
  • references/code-discipline.md
  • references/code-discipline.md.AGENTS.md
  • references/rebuild-matrix.md
  • references/rebuild-matrix.md.AGENTS.md
  • scripts/check-mode.ts
  • scripts/check-mode.ts.AGENTS.md
  • scripts/full-rebuild.ts
  • scripts/full-rebuild.ts.AGENTS.md
  • scripts/parse-findings.ts
  • scripts/parse-findings.ts.AGENTS.md
  • scripts/restart-server.ts
  • scripts/restart-server.ts.AGENTS.md
  • scripts/review-changes.ts
  • scripts/review-changes.ts.AGENTS.md

Open the folder on GitHubat commit e23e533

Compare with similar skills

Implement next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Implement compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Implement this skillBlackBeltTechnology/pi-agent-dashboard315—~2kAutomated safety check: PassMIT
Rust TDD Workflowrtk-ai/rtk83k—~753Automated safety check: NotesApache-2.0
RTK Filter TDD in Rustrtk-ai/rtk83k—~1.9kAutomated safety check: NotesApache-2.0
Test Guidelinesgetsentry/sentry-dart873—~3.1kAutomated safety check: PassMIT
Evidence-First Development LoopAmazingAng/old-coder749—~5.4kAutomated safety check: NotesMIT
Gh IssuesTypedDevs/bashunit4341 repos~1.7kAutomated safety check: NotesMIT

Similar skills

  • Rust TDD Workflow

    rtk-ai/rtk

    Enforces red-green-refactor for Rust work, with idiomatic test patterns, a naming convention and a pre-commit gate of cargo fmt, clippy and test.

    83k GitHub stars~753 tokensUpdated today
    Testing & QAAuto-check: notes

  • RTK Filter TDD in Rust

    rtk-ai/rtk

    Enforces red-green-refactor for new RTK output filters in Rust, using real captured fixtures, snapshot tests with insta and token-savings assertions.

    83k GitHub stars~1.9k tokensUpdated today
    Testing & QAAuto-check: notes

  • Test Guidelines

    getsentry/sentry-dart

    Official

    Enforce Sentry Dart/Flutter SDK test conventions for naming, structure, and fixtures.

    873 GitHub stars~3.1k tokensUpdated yesterday
    Testing & QAAuto-check passed

  • Evidence-First Development Loop

    AmazingAng/old-coder

    Replaces line-by-line code review with an approved executable spec and a gauntlet of tests, types, coverage, and mutation checks the code must survive.

    749 GitHub stars~5.4k tokensUpdated 1 mo ago
    Testing & QAAuto-check: notes

  • Gh Issues

    TypedDevs/bashunit

    Walk over all open GitHub issues that are unassigned or assigned to the current user, and process each one via the /gh-issue skill, sequentially.

    434 GitHub starsUsed in 1 repo~1.7k tokens
    Testing & QAAuto-check: notes

  • Agent Harness Testing Methodology

    huiliyi37/Tianshu-harness

    Guides an agent through probing an unfamiliar project's test setup, then choosing a red-light-first testing strategy matched to the task type.

    1.1k GitHub stars~1k tokensUpdated today
    Testing & QAAuto-check: notes

More from BlackBeltTechnology/pi-agent-dashboard

All 66 skills in this repo

  • Browser

    BlackBeltTechnology/pi-agent-dashboard

    Browser automation via the agent-browser CLI. An agent skill from BlackBeltTechnology/pi-agent-dashboard.

    315 GitHub starsUsed in 1 repo~2k tokens
    Auto-check passed

  • Pi Dashboard

    BlackBeltTechnology/pi-agent-dashboard

    Monitor and control the pi-dashboard server. An agent skill from BlackBeltTechnology/pi-agent-dashboard.

    315 GitHub starsUsed in 1 repo~2.2k tokens
    Auto-check passed

  • CI Troubleshoot

    BlackBeltTechnology/pi-agent-dashboard

    Diagnose failed GitHub Actions runs for pi-agent-dashboard: the 11-file workflow taxonomy, affected-test selection, the release pipeline, known failure modes, and how to read gh run logs and…

    315 GitHub stars~3.5k tokensUpdated today
    Auto-check passed

  • Debug Dashboard

    BlackBeltTechnology/pi-agent-dashboard

    Diagnose problems in the running pi-agent-dashboard system: server.log, /api/health, bridge WebSocket connectivity, vitest triage, known-issue FAQ entries.

    315 GitHub stars~1.6k tokensUpdated today
    Auto-check passed

  • Session To Guideline

    BlackBeltTechnology/pi-agent-dashboard

    Turn a pi session into a Markdown "how-we-did-it" collaboration guideline: reads the session's JSONL transcript and synthesizes a reusable playbook of which prompts worked, what had to be steered…

    315 GitHub stars~3.2k tokensUpdated today
    Auto-check passed

  • Bpmn Package Explorer

    BlackBeltTechnology/pi-agent-dashboard

    Generate, validate and view BPMN 2.0 process packages from a prose description, and render existing .bpmn / .dmn files.

    315 GitHub stars~1.7k tokensUpdated today
    Auto-check passed

Categories

Questions about Implement

What does Implement do?

Disciplined implementation in pi-agent-dashboard: the rebuild matrix (extension→reload, server→restart, client→build+restart, openspec-apply→full rebuild) plus the project's code discipline rules. Implement is an agent skill from BlackBeltTechnology/pi-agent-dashboard. Disciplined implementation in pi-agent-dashboard: the rebuild matrix (extension→reload, server→restart, client→build+restart, openspec-apply→full rebuild) plus the project's code discipline rules.

When should I use Implement?

Implement fits situations like: after editing extension/server/client; after applying an OpenSpec change; unsure what to rebuild; before committing.

How do I install Implement in Claude Code?

Run `npx skills add BlackBeltTechnology/pi-agent-dashboard --skill implement -a claude-code`. Or copy the skill folder (.pi/skills/implement in BlackBeltTechnology/pi-agent-dashboard) into .claude/skills/implement in your project. Claude Code loads it when a task matches its description.

How do I install Implement in Codex?

Run `npx skills add BlackBeltTechnology/pi-agent-dashboard --skill implement -a codex`. Or copy the skill folder (.pi/skills/implement in BlackBeltTechnology/pi-agent-dashboard) into .agents/skills/implement in your project. Codex loads it when a task matches its description.

Can I use Implement in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add BlackBeltTechnology/pi-agent-dashboard --skill implement -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/implement, .gemini/skills/implement, .github/skills/implement and .opencode/skills/implement in your project.

What does Implement need to run?

Going by SKILL.md and its folder, Implement needs TypeScript for the scripts in its folder and the command-line tools its instructions call (npx, npm and git). Our summary lists: Node.js; Docker.

Does Implement access the network?

SKILL.md contains no URLs. Its commands use npx, npm and git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Implement safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Implement use?

Implement is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Implement use?

About 2k tokens (SKILL.md is roughly 8.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 3.2k tokens, read only when the agent opens those files.

What are the alternatives to Implement?

Skills that share tags, products or a category with Implement: Rust TDD Workflow (rtk-ai/rtk, 83k stars), RTK Filter TDD in Rust (rtk-ai/rtk, 83k stars), Test Guidelines (getsentry/sentry-dart, 873 stars) and Evidence-First Development Loop (AmazingAng/old-coder, 749 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Implement?

BlackBeltTechnology (a GitHub organization) maintains it in BlackBeltTechnology/pi-agent-dashboard, which has 315 GitHub stars. The repository holds 66 skills in this directory. The repository was last updated on October 8, 2026.

Source: BlackBeltTechnology/pi-agent-dashboard on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.