diff --git a/agent/skills/ask-matt b/agent/skills/ask-matt new file mode 120000 index 0000000..f5fd021 --- /dev/null +++ b/agent/skills/ask-matt @@ -0,0 +1 @@ +/home/blank/.agents/skills/ask-matt \ No newline at end of file diff --git a/agent/skills/chief-of-staff b/agent/skills/chief-of-staff new file mode 120000 index 0000000..d005991 --- /dev/null +++ b/agent/skills/chief-of-staff @@ -0,0 +1 @@ +/home/blank/.agents/skills/chief-of-staff \ No newline at end of file diff --git a/agent/skills/claude-handoff b/agent/skills/claude-handoff new file mode 120000 index 0000000..29a5f60 --- /dev/null +++ b/agent/skills/claude-handoff @@ -0,0 +1 @@ +/home/blank/.agents/skills/claude-handoff \ No newline at end of file diff --git a/agent/skills/code-review b/agent/skills/code-review new file mode 120000 index 0000000..4e2cea2 --- /dev/null +++ b/agent/skills/code-review @@ -0,0 +1 @@ +/home/blank/.agents/skills/code-review \ No newline at end of file diff --git a/agent/skills/code-review/SKILL.md b/agent/skills/code-review/SKILL.md deleted file mode 100644 index 373a4f2..0000000 --- a/agent/skills/code-review/SKILL.md +++ /dev/null @@ -1,89 +0,0 @@ ---- -name: code-review -description: "Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes: Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match what the originating issue/spec asked for?). Runs both reviews in parallel sub-agents and reports them side by side. Use when the user wants to review a branch, a PR, work-in-progress changes, or asks to \"review since X\"." ---- - -Two-axis review of the diff between `HEAD` and a fixed point the user supplies: - -- **Standards**: does the code conform to this repo's documented coding standards? -- **Spec**: does the code faithfully implement the originating issue / spec? - -Both axes run as **parallel sub-agents** so they don't pollute each other's context, then this skill aggregates their findings. - -The issue tracker should have been provided to you. If not, tell the user to run `/setup-matt-pocock-skills`. - -## Process - -### 1. Pin the fixed point - -Whatever the user said is the fixed point (a commit SHA, branch name, tag, `main`, `HEAD~5`, etc.). If they didn't specify one, ask for it. - -Capture the diff command once: `git diff ...HEAD` (three-dot, so the comparison is against the merge-base). Also note the list of commits via `git log ..HEAD --oneline`. - -Before going further, confirm the fixed point resolves (`git rev-parse `) and the diff is non-empty. A bad ref or empty diff should fail here, not inside two parallel sub-agents. - -### 2. Identify the spec source - -Look for the originating spec, in this order: - -1. Issue references in the commit messages (`#123`, `Closes #45`, GitLab `!67`, etc.), fetched via the workflow in the tracker doc. -2. A path the user passed as an argument. -3. A spec file under `docs/`, `specs/`, or `.scratch/` matching the branch name or feature. -4. If nothing is found, ask the user where the spec is. If they say there isn't one, the **Spec** sub-agent will skip and report "no spec available". - -### 3. Identify the standards sources - -Search the repo for every file that documents how code should be written. When `CODING_STANDARDS.md` or `CONTRIBUTING.md` exists, it must be on the list. - -On top of whatever the repo documents, the Standards axis always carries the **smell baseline** below: a fixed set of Fowler code smells (_Refactoring_, ch.3) that applies even when a repo documents nothing. Two rules bind it: - -- **The repo overrides.** A documented repo standard always wins; where it endorses something the baseline would flag, suppress the smell. -- **Always a judgement call.** Each smell is a labelled heuristic ("possible Feature Envy"), never a hard violation. Like any standard here, skip anything tooling already enforces. - -Each smell reads *what it is* → *how to fix*; match it against the diff: - -- **Mysterious Name**: a function, variable, or type whose name doesn't reveal what it does or holds. → rename it; if no honest name comes, the design's murky. -- **Duplicated Code**: the same logic shape appears in more than one hunk or file in the change. → extract the shared shape, call it from both. -- **Feature Envy**: a method that reaches into another object's data more than its own. → move the method onto the data it envies. -- **Data Clumps**: the same few fields or params keep travelling together (a type wanting to be born). → bundle them into one type, pass that. -- **Primitive Obsession**: a primitive or string standing in for a domain concept that deserves its own type. → give the concept its own small type. -- **Repeated Switches**: the same `switch`/`if`-cascade on the same type recurs across the change. → replace with polymorphism, or one map both sites share. -- **Shotgun Surgery**: one logical change forces scattered edits across many files in the diff. → gather what changes together into one module. -- **Divergent Change**: one file or module is edited for several unrelated reasons. → split so each module changes for one reason. -- **Speculative Generality**: abstraction, parameters, or hooks added for needs the spec doesn't have. → delete it; inline back until a real need shows. -- **Message Chains**: long `a.b().c().d()` navigation the caller shouldn't depend on. → hide the walk behind one method on the first object. -- **Middle Man**: a class or function that mostly just delegates onward. → cut it, call the real target direct. -- **Refused Bequest**: a subclass or implementer that ignores or overrides most of what it inherits. → drop the inheritance, use composition. - -### 4. Spawn both sub-agents in parallel - -Issue both sub-agent calls together, in the foreground, and aggregate the reports they return. - -**Standards sub-agent prompt** should include: - -- The full diff command and commit list. -- The list of standards-source files you found in step 3, **plus the smell baseline from step 3** pasted in full (the sub-agent has no other access to it). -- The brief: "Report, per file/hunk where relevant, (a) every place the diff violates a documented standard: cite the standard (file + the rule); and (b) any baseline smell you spot: name it and quote the hunk. Distinguish hard violations from judgement calls: documented-standard breaches can be hard, but baseline smells are always judgement calls, and a documented repo standard overrides the baseline. Skip anything tooling enforces. Under 400 words." - -**Spec sub-agent prompt** should include: - -- The diff command and commit list. -- The path or fetched contents of the spec. -- The brief: "Report: (a) requirements the spec asked for that are missing or partial; (b) behaviour in the diff that wasn't asked for (scope creep); (c) requirements that look implemented but where the implementation looks wrong. Quote the spec line for each finding. Under 400 words." - -If the spec is missing, skip the Spec sub-agent and note this in the final report. - -### 5. Aggregate - -Present the two reports under `## Standards` and `## Spec` headings, verbatim or lightly cleaned. Do **not** merge or rerank findings, because the two axes are deliberately separate (see _Why two axes_). - -End with a one-line summary: total findings per axis, and the worst issue _within each axis_ (if any). Don't pick a single winner across axes: that's the reranking the separation exists to prevent. - -## Why two axes - -A change can pass one axis and fail the other: - -- Code that follows every standard but implements the wrong thing → **Standards pass, Spec fail.** -- Code that does exactly what the issue asked but breaks the project's conventions → **Spec pass, Standards fail.** - -Reporting them separately stops one axis from masking the other. diff --git a/agent/skills/code-review/agents/openai.yaml b/agent/skills/code-review/agents/openai.yaml deleted file mode 100644 index 9076774..0000000 --- a/agent/skills/code-review/agents/openai.yaml +++ /dev/null @@ -1,3 +0,0 @@ -interface: - display_name: "Code Review" - short_description: "Review a diff on standards and spec" diff --git a/agent/skills/codebase-design b/agent/skills/codebase-design new file mode 120000 index 0000000..ab974d7 --- /dev/null +++ b/agent/skills/codebase-design @@ -0,0 +1 @@ +/home/blank/.agents/skills/codebase-design \ No newline at end of file diff --git a/agent/skills/diagnosing-bugs b/agent/skills/diagnosing-bugs new file mode 120000 index 0000000..566b645 --- /dev/null +++ b/agent/skills/diagnosing-bugs @@ -0,0 +1 @@ +/home/blank/.agents/skills/diagnosing-bugs \ No newline at end of file diff --git a/agent/skills/diagnosing-bugs/SKILL.md b/agent/skills/diagnosing-bugs/SKILL.md deleted file mode 100644 index d039541..0000000 --- a/agent/skills/diagnosing-bugs/SKILL.md +++ /dev/null @@ -1,138 +0,0 @@ ---- -name: diagnosing-bugs -description: Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow. ---- - -# Diagnosing Bugs - -A discipline for hard bugs. Skip phases only when explicitly justified. - -When exploring the codebase, read `GLOSSARY.md` (if it exists) to get a clear mental model of the relevant modules, and check ADRs in the area you're touching. - -## Redact - -This skill has you show commands, outputs and captured artifacts. **Redact every secret first**: write `` in its place. Build loops against env vars, so the credential stays in the environment rather than in what you show. Captured artifacts carry auth headers: quote only the lines that carry the signal. - -If the redacted output is not enough to diagnose the bug, say so and ask the user. - -## Phase 1: Build a feedback loop - -**This is the skill.** Everything else is mechanical. If you have a **tight** pass/fail signal for the bug (one that goes red on _this_ bug), you will find the cause; bisection, hypothesis-testing, and instrumentation all just consume it. If you don't have one, no amount of staring at code will save you. - -Spend disproportionate effort here. **Be aggressive. Be creative. Refuse to give up.** - -### Ways to construct one, in roughly this order - -1. **Failing test** at whatever seam reaches the bug: unit, integration, e2e. -2. **Curl / HTTP script** against a running dev server. -3. **CLI invocation** with a fixture input, diffing stdout against a known-good snapshot. -4. **Headless browser script** (Playwright / Puppeteer) that drives the UI and asserts on DOM/console/network. -5. **Replay a captured trace.** Save a real network request / payload / event log to disk; replay it through the code path in isolation. -6. **Throwaway harness.** Spin up a minimal subset of the system (one service, mocked deps) that exercises the bug code path with a single function call. -7. **Property / fuzz loop.** If the bug is "sometimes wrong output", run 1000 random inputs and look for the failure mode. -8. **Bisection harness.** If the bug appeared between two known states (commit, dataset, version), automate "boot at state X, check, repeat" so you can `git bisect run` it. -9. **Differential loop.** Run the same input through old-version vs new-version (or two configs) and diff outputs. -10. **HITL bash script.** Last resort. If a human must click, drive _them_ with `scripts/hitl-loop.template.sh` so the loop is still structured. Captured output feeds back to you. - -Build the right feedback loop, and the bug is 90% fixed. - -### Tighten the loop - -Treat the loop as a product. Once you have _a_ loop, **tighten** it: - -- Can I make it faster? (Cache setup, skip unrelated init, narrow the test scope.) -- Can I make the signal sharper? (Assert on the specific symptom, not "didn't crash".) -- Can I make it more deterministic? (Pin time, seed RNG, isolate filesystem, freeze network.) - -A 30-second flaky loop is barely better than no loop; a 2-second deterministic one is tight, a debugging superpower. - -### Non-deterministic bugs - -The goal is not a clean repro but a **higher reproduction rate**. Loop the trigger 100×, parallelise, add stress, narrow timing windows, inject sleeps. A 50%-flake bug is debuggable; 1% is not, so keep raising the rate until it's debuggable. - -### When you genuinely cannot build a loop - -Stop and say so explicitly. List what you tried. Ask the user for: (a) access to whatever environment reproduces it, (b) a redacted captured artifact (HAR file, log dump, core dump, screen recording with timestamps), or (c) permission to add temporary production instrumentation. Do **not** proceed to hypothesise without a loop. - -### Completion criterion: a tight loop that goes red - -Phase 1 is done when the loop is **tight** and **red-capable**: you can name **one command** (a script path, a test invocation, a curl) that you have **already run at least once** (show the invocation and its output, redacted), and that is: - -- [ ] **Red-capable**: it drives the actual bug code path and asserts the **user's exact symptom**, so it can go red on this bug and green once fixed. Not "runs without erroring"; it must be able to _catch this specific bug_. -- [ ] **Deterministic**: same verdict every run (flaky bugs: a pinned, high reproduction rate, per above). -- [ ] **Fast**: seconds, not minutes. -- [ ] **Agent-runnable**: you can run it unattended; a human in the loop only via `scripts/hitl-loop.template.sh`. - -If you catch yourself reading code to build a theory before this command exists, **stop: jumping straight to a hypothesis is the exact failure this skill prevents.** No red-capable command, no Phase 2. - -## Phase 2: Reproduce + minimise - -Run the loop. Watch it go red as the bug appears. - -Confirm: - -- [ ] The loop produces the failure mode the **user** described, not a different failure that happens to be nearby. Wrong bug = wrong fix. -- [ ] The failure is reproducible across multiple runs (or, for non-deterministic bugs, reproducible at a high enough rate to debug against). -- [ ] You have captured the exact symptom (error message, wrong output, slow timing) so later phases can verify the fix actually addresses it. - -### Minimise - -Once it's red, shrink the repro to the **smallest scenario that still goes red**. Cut inputs, callers, config, data, and steps **one at a time**, re-running the loop after each cut, and keep only what's load-bearing for the failure. - -Why bother: a minimal repro shrinks the hypothesis space in Phase 3 (fewer moving parts left to suspect) and becomes the clean regression test in Phase 5. - -Done when **every remaining element is load-bearing**: removing any one of them makes the loop go green. - -Do not proceed until you have reproduced **and** minimised. - -## Phase 3: Hypothesise - -Generate **3–5 ranked hypotheses** before testing any of them. Single-hypothesis generation anchors on the first plausible idea. - -Each hypothesis must be **falsifiable**: state the prediction it makes. - -> Format: "If is the cause, then will make the bug disappear / will make it worse." - -If you cannot state the prediction, the hypothesis is a vibe: discard or sharpen it. - -**Show the ranked list to the user before testing.** They often have domain knowledge that re-ranks instantly ("we just deployed a change to #3"), or know hypotheses they've already ruled out. Cheap checkpoint, big time saver. Don't block on it; proceed with your ranking if the user is AFK. - -## Phase 4: Instrument - -Each probe must map to a specific prediction from Phase 3. **Change one variable at a time.** - -Tool preference: - -1. **Debugger / REPL inspection** if the env supports it. One breakpoint beats ten logs. -2. **Targeted logs** at the boundaries that distinguish hypotheses. -3. Never "log everything and grep". - -**Tag every debug log** with a unique prefix, e.g. `[DEBUG-a4f2]`. Cleanup at the end becomes a single grep. Untagged logs survive; tagged logs die. - -**Perf branch.** For performance regressions, logs are usually wrong. Instead: establish a baseline measurement (timing harness, `performance.now()`, profiler, query plan), then bisect. Measure first, fix second. - -## Phase 5: Fix + regression test - -Write the regression test **before the fix**, but only if there is a **correct seam** for it. - -A correct seam is one where the test exercises the **real bug pattern** as it occurs at the call site. If the only available seam is too shallow (single-caller test when the bug needs multiple callers, unit test that can't replicate the chain that triggered the bug), a regression test there gives false confidence. - -**If no correct seam exists, that itself is the finding.** Note it. The codebase architecture is preventing the bug from being locked down. Flag this for the next phase. - -If a correct seam exists: - -1. Turn the minimised repro into a failing test at that seam. -2. Watch it fail. If you forced the red by mutating code or a fixture, `diff` against a pristine copy to prove the mutation landed before you trust it. -3. Apply the fix. -4. Watch it pass. -5. Re-run the Phase 1 feedback loop against the original (un-minimised) scenario. - -## Phase 6: Cleanup - -Required before declaring done: - -- [ ] Original repro no longer reproduces (re-run the Phase 1 loop) -- [ ] Regression test passes (or absence of seam is documented) -- [ ] All `[DEBUG-...]` instrumentation removed (`grep` the prefix) -- [ ] Throwaway prototypes deleted (or moved to a clearly-marked debug location) -- [ ] The hypothesis that turned out correct is stated in the commit / PR message, so the next debugger learns diff --git a/agent/skills/diagnosing-bugs/agents/openai.yaml b/agent/skills/diagnosing-bugs/agents/openai.yaml deleted file mode 100644 index a13a755..0000000 --- a/agent/skills/diagnosing-bugs/agents/openai.yaml +++ /dev/null @@ -1,3 +0,0 @@ -interface: - display_name: "Diagnosing Bugs" - short_description: "Diagnose hard bugs and regressions" diff --git a/agent/skills/diagnosing-bugs/scripts/hitl-loop.template.sh b/agent/skills/diagnosing-bugs/scripts/hitl-loop.template.sh deleted file mode 100644 index 2431984..0000000 --- a/agent/skills/diagnosing-bugs/scripts/hitl-loop.template.sh +++ /dev/null @@ -1,44 +0,0 @@ -#!/usr/bin/env bash -# Human-in-the-loop reproduction loop. -# Copy this file, edit the steps below, and run it. -# The agent runs the script; the user follows prompts in their terminal. -# -# Usage: -# bash hitl-loop.template.sh -# -# Two helpers: -# step "" → show instruction, wait for Enter -# capture VAR "" → show question, read response into VAR -# -# At the end, captured values are printed as KEY=VALUE for the agent to parse. -# -# `capture` prints its value back to the terminal, where the agent reads it, -# so capture observations, and leave signing in to the user as a `step`. - -set -euo pipefail - -step() { - printf '\n>>> %s\n' "$1" - read -r -p " [Enter when done] " _ -} - -capture() { - local var="$1" question="$2" answer - printf '\n>>> %s\n' "$question" - read -r -p " > " answer - printf -v "$var" '%s' "$answer" -} - -# --- edit below --------------------------------------------------------- - -step "Open the app at http://localhost:3000 and sign in." - -capture ERRORED "Click the 'Export' button. Did it throw an error? (y/n)" - -capture ERROR_MSG "Paste the error message (or 'none'):" - -# --- edit above --------------------------------------------------------- - -printf '\n--- Captured ---\n' -printf 'ERRORED=%s\n' "$ERRORED" -printf 'ERROR_MSG=%s\n' "$ERROR_MSG" diff --git a/agent/skills/domain-modeling b/agent/skills/domain-modeling new file mode 120000 index 0000000..91118be --- /dev/null +++ b/agent/skills/domain-modeling @@ -0,0 +1 @@ +/home/blank/.agents/skills/domain-modeling \ No newline at end of file diff --git a/agent/skills/find-skills b/agent/skills/find-skills new file mode 120000 index 0000000..6c2b6b2 --- /dev/null +++ b/agent/skills/find-skills @@ -0,0 +1 @@ +/home/blank/.agents/skills/find-skills \ No newline at end of file diff --git a/agent/skills/find-skills/SKILL.md b/agent/skills/find-skills/SKILL.md deleted file mode 100644 index a41bdd0..0000000 --- a/agent/skills/find-skills/SKILL.md +++ /dev/null @@ -1,141 +0,0 @@ ---- -name: find-skills -description: Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill. ---- - -# Find Skills - -This skill helps you discover and install skills from the open agent skills ecosystem. - -## When to Use This Skill - -Use this skill when the user: - -- Asks "how do I do X" where X might be a common task with an existing skill -- Says "find a skill for X" or "is there a skill for X" -- Asks "can you do X" where X is a specialized capability -- Expresses interest in extending agent capabilities -- Wants to search for tools, templates, or workflows -- Mentions they wish they had help with a specific domain (design, testing, deployment, etc.) - -## What is the Skills CLI? - -The Skills CLI (`npx skills`) is the package manager for the open agent skills ecosystem. Skills are modular packages that extend agent capabilities with specialized knowledge, workflows, and tools. - -**Key commands:** - -- `npx skills find [query] [--owner ]` - Search for skills interactively or by keyword, optionally scoped to a GitHub owner -- `npx skills add ` - Install a skill from GitHub or other sources -- `npx skills update` - Update all installed skills - -**Browse skills at:** https://skills.sh/ - -## How to Help Users Find Skills - -### Step 1: Understand What They Need - -When a user asks for help with something, identify: - -1. The domain (e.g., React, testing, design, deployment) -2. The specific task (e.g., writing tests, creating animations, reviewing PRs) -3. Whether this is a common enough task that a skill likely exists - -### Step 2: Check the Leaderboard First - -Before running a CLI search, check the [skills.sh leaderboard](https://skills.sh/) to see if a well-known skill already exists for the domain. The leaderboard ranks skills by total installs, surfacing the most popular and battle-tested options. - -For example, top skills for web development include: -- `vercel-labs/agent-skills` — React, Next.js, web design (100K+ installs each) -- `anthropics/skills` — Frontend design, document processing (100K+ installs) - -### Step 3: Search for Skills - -If the leaderboard doesn't cover the user's need, run the find command: - -```bash -npx skills find [query] [--owner ] -``` - -For example: - -- User asks "how do I make my React app faster?" → `npx skills find react performance` -- User asks "can you help me with PR reviews?" → `npx skills find pr review` -- User asks "I need to create a changelog" → `npx skills find changelog` - -### Step 4: Verify Quality Before Recommending - -**Do not recommend a skill based solely on search results.** Always verify: - -1. **Install count** — Prefer skills with 1K+ installs. Be cautious with anything under 100. -2. **Source reputation** — Official sources (`vercel-labs`, `anthropics`, `microsoft`) are more trustworthy than unknown authors. -3. **GitHub stars** — Check the source repository. A skill from a repo with <100 stars should be treated with skepticism. - -### Step 5: Present Options to the User - -When you find relevant skills, present them to the user with: - -1. The skill name and what it does -2. The install count and source -3. The install command they can run -4. A link to learn more at skills.sh - -Example response: - -``` -I found a skill that might help! The "react-best-practices" skill provides -React and Next.js performance optimization guidelines from Vercel Engineering. -(185K installs) - -To install it: -npx skills add vercel-labs/agent-skills@react-best-practices - -Learn more: https://skills.sh/vercel-labs/agent-skills/react-best-practices -``` - -### Step 6: Offer to Install - -If the user wants to proceed, you can install the skill for them: - -```bash -npx skills add -g -y -``` - -The `-g` flag installs globally (user-level) and `-y` skips confirmation prompts. - -## Common Skill Categories - -When searching, consider these common categories: - -| Category | Example Queries | -| --------------- | ---------------------------------------- | -| Web Development | react, nextjs, typescript, css, tailwind | -| Testing | testing, jest, playwright, e2e | -| DevOps | deploy, docker, kubernetes, ci-cd | -| Documentation | docs, readme, changelog, api-docs | -| Code Quality | review, lint, refactor, best-practices | -| Design | ui, ux, design-system, accessibility | -| Productivity | workflow, automation, git | - -## Tips for Effective Searches - -1. **Use specific keywords**: "react testing" is better than just "testing" -2. **Try alternative terms**: If "deploy" doesn't work, try "deployment" or "ci-cd" -3. **Check popular sources**: Many skills come from `vercel-labs/agent-skills` or `ComposioHQ/awesome-claude-skills` - -## When No Skills Are Found - -If no relevant skills exist: - -1. Acknowledge that no existing skill was found -2. Offer to help with the task directly using your general capabilities -3. Suggest the user could create their own skill with `npx skills init` - -Example: - -``` -I searched for skills related to "xyz" but didn't find any matches. -I can still help you with this task directly! Would you like me to proceed? - -If this is something you do often, you could create your own skill: -npx skills init my-xyz-skill -``` diff --git a/agent/skills/git-guardrails-claude-code b/agent/skills/git-guardrails-claude-code new file mode 120000 index 0000000..9901446 --- /dev/null +++ b/agent/skills/git-guardrails-claude-code @@ -0,0 +1 @@ +/home/blank/.agents/skills/git-guardrails-claude-code \ No newline at end of file diff --git a/agent/skills/grill-me b/agent/skills/grill-me new file mode 120000 index 0000000..2ff8488 --- /dev/null +++ b/agent/skills/grill-me @@ -0,0 +1 @@ +/home/blank/.agents/skills/grill-me \ No newline at end of file diff --git a/agent/skills/grill-with-docs b/agent/skills/grill-with-docs new file mode 120000 index 0000000..79815c9 --- /dev/null +++ b/agent/skills/grill-with-docs @@ -0,0 +1 @@ +/home/blank/.agents/skills/grill-with-docs \ No newline at end of file diff --git a/agent/skills/grilling b/agent/skills/grilling new file mode 120000 index 0000000..b05c3eb --- /dev/null +++ b/agent/skills/grilling @@ -0,0 +1 @@ +/home/blank/.agents/skills/grilling \ No newline at end of file diff --git a/agent/skills/grilling/SKILL.md b/agent/skills/grilling/SKILL.md deleted file mode 100644 index df69d99..0000000 --- a/agent/skills/grilling/SKILL.md +++ /dev/null @@ -1,30 +0,0 @@ ---- -name: grilling -description: Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases. ---- - -Interview the user relentlessly until you reach a shared understanding. Map this as a **design tree**: every decision branches into the decisions that hang off it. - -Work the tree in **rounds**. The **frontier** is every decision whose prerequisites are already settled: the questions you can ask _now_ without guessing at answers you haven't heard yet. Ask the whole frontier in one round: number each question and give your recommended answer. Then wait for the user's answers before the next round. - -Format a round like so: - -``` -❓ **Q1** - ****: - -➡️ - ---- - -❓ **Q2** - ****: - -➡️ -``` - -Word each question so "yes" accepts your recommended answer. - -Each round the user answers reshapes the tree: settled decisions push the frontier outward and unblock questions that depended on them. Recompute the frontier and ask the next round. A question whose answer depends on another question still open in this round belongs to a _later_ round, not this one. - -Finding _facts_ is your job, never the user's. When a frontier question needs a fact from the environment (filesystem, tools, etc.), dispatch a sub-agent to find it; don't ask the user for anything you could look up yourself. Don't block on it: a running exploration is an unsettled prerequisite, so only the questions downstream of it wait for the sub-agent to report; ask the rest of the frontier now. The _decisions_ are the user's: put each to them and wait. - -The session is done when the frontier is empty: every branch of the design tree visited, nothing left silently assumed. Do not act on it until the user confirms you have reached a shared understanding. diff --git a/agent/skills/grilling/agents/openai.yaml b/agent/skills/grilling/agents/openai.yaml deleted file mode 100644 index ddbdb96..0000000 --- a/agent/skills/grilling/agents/openai.yaml +++ /dev/null @@ -1,3 +0,0 @@ -interface: - display_name: "Grilling" - short_description: "Stress-test thinking a round of questions at a time" diff --git a/agent/skills/handoff b/agent/skills/handoff new file mode 120000 index 0000000..98b7fa0 --- /dev/null +++ b/agent/skills/handoff @@ -0,0 +1 @@ +/home/blank/.agents/skills/handoff \ No newline at end of file diff --git a/agent/skills/handoff/SKILL.md b/agent/skills/handoff/SKILL.md deleted file mode 100644 index a224edc..0000000 --- a/agent/skills/handoff/SKILL.md +++ /dev/null @@ -1,16 +0,0 @@ ---- -name: handoff -description: Compact the current conversation into a handoff document for another agent to pick up. -argument-hint: "What will the next session be used for?" -disable-model-invocation: true ---- - -Write a handoff document summarising the current conversation so a fresh agent can continue the work. Save to the temporary directory of the user's OS (`$TMPDIR`, else `/tmp`; `%TEMP%` on Windows) - not the current workspace. - -Include a "suggested skills" section in the document, naming which skills the next agent should call the Skill tool for. - -Do not duplicate content already captured in other artifacts (specs, plans, ADRs, issues, commits, diffs). Reference them by path or URL instead. - -Redact any sensitive information, such as API keys, passwords, or personally identifiable information. - -If the user passed arguments, treat them as a description of what the next session will focus on and tailor the doc accordingly. diff --git a/agent/skills/handoff/agents/openai.yaml b/agent/skills/handoff/agents/openai.yaml deleted file mode 100644 index 6e1d8da..0000000 --- a/agent/skills/handoff/agents/openai.yaml +++ /dev/null @@ -1,5 +0,0 @@ -interface: - display_name: "Handoff" - short_description: "Compact a conversation into a handoff" -policy: - allow_implicit_invocation: false diff --git a/agent/skills/implement b/agent/skills/implement new file mode 120000 index 0000000..13d0085 --- /dev/null +++ b/agent/skills/implement @@ -0,0 +1 @@ +/home/blank/.agents/skills/implement \ No newline at end of file diff --git a/agent/skills/implement-spec b/agent/skills/implement-spec new file mode 120000 index 0000000..2b703e2 --- /dev/null +++ b/agent/skills/implement-spec @@ -0,0 +1 @@ +/home/blank/.agents/skills/implement-spec \ No newline at end of file diff --git a/agent/skills/implement/SKILL.md b/agent/skills/implement/SKILL.md deleted file mode 100644 index bd49e47..0000000 --- a/agent/skills/implement/SKILL.md +++ /dev/null @@ -1,17 +0,0 @@ ---- -name: implement -description: "Implement a piece of work based on a spec or set of tickets." -disable-model-invocation: true ---- - -Implement the work described by the user in the spec or tickets. - -If the user passes a ticket reference, fetch it from the issue tracker and state its title before starting. If the reference is ambiguous, ask. - -Call the Skill tool with "tdd" where possible, at pre-agreed seams. - -Run typechecking regularly, single test files regularly, and the full test suite once at the end. - -Once done, call the Skill tool with "code-review" to review the work. - -Commit your work to the current branch. diff --git a/agent/skills/implement/agents/openai.yaml b/agent/skills/implement/agents/openai.yaml deleted file mode 100644 index f8794dc..0000000 --- a/agent/skills/implement/agents/openai.yaml +++ /dev/null @@ -1,5 +0,0 @@ -interface: - display_name: "Implement" - short_description: "Build work from a spec or tickets" -policy: - allow_implicit_invocation: false diff --git a/agent/skills/improve-codebase-architecture b/agent/skills/improve-codebase-architecture new file mode 120000 index 0000000..62e8598 --- /dev/null +++ b/agent/skills/improve-codebase-architecture @@ -0,0 +1 @@ +/home/blank/.agents/skills/improve-codebase-architecture \ No newline at end of file diff --git a/agent/skills/loop-me b/agent/skills/loop-me new file mode 120000 index 0000000..26b8d5a --- /dev/null +++ b/agent/skills/loop-me @@ -0,0 +1 @@ +/home/blank/.agents/skills/loop-me \ No newline at end of file diff --git a/agent/skills/migrate-to-shoehorn b/agent/skills/migrate-to-shoehorn new file mode 120000 index 0000000..1f8e546 --- /dev/null +++ b/agent/skills/migrate-to-shoehorn @@ -0,0 +1 @@ +/home/blank/.agents/skills/migrate-to-shoehorn \ No newline at end of file diff --git a/agent/skills/pr b/agent/skills/pr new file mode 120000 index 0000000..cef2aef --- /dev/null +++ b/agent/skills/pr @@ -0,0 +1 @@ +/home/blank/.agents/skills/pr \ No newline at end of file diff --git a/agent/skills/prototype b/agent/skills/prototype new file mode 120000 index 0000000..4f785e8 --- /dev/null +++ b/agent/skills/prototype @@ -0,0 +1 @@ +/home/blank/.agents/skills/prototype \ No newline at end of file diff --git a/agent/skills/prototype/LOGIC.md b/agent/skills/prototype/LOGIC.md deleted file mode 100644 index 32be86a..0000000 --- a/agent/skills/prototype/LOGIC.md +++ /dev/null @@ -1,67 +0,0 @@ -# Logic Prototype - -A single, self-contained HTML file (a **shareable demo**) that lets anyone drive a state model by clicking buttons. Use this when the question is about **business logic, state transitions, or data shape**: the kind of thing that looks reasonable on paper but only feels wrong once you push it through real cases. - -Because it's one file with nothing to install, you can hand it to a non-developer (a designer, a PM, a domain expert) and let them feel the model for themselves. So it speaks their language, not the code's. - -## When this is the right shape - -- "I'm not sure if this state machine handles the edge case where X then Y." -- "Does this data model actually let me represent the case where..." -- "I want to feel out what the API should look like before writing it." -- Anything where someone wants to **press buttons and watch state change**. - -If the question is "what should this look like," this is the wrong branch. Use [UI.md](UI.md). - -## Process - -### 1. State the question - -Before writing code, write down what state model and what question you're prototyping. One paragraph, at the top of the demo (in a visible intro, not just a comment). A logic prototype that answers the wrong question is pure waste, so make the question explicit so it can be checked later, whether the user is watching now or returning to it AFK. - -### 2. Isolate the logic in a portable module - -Put the actual logic (the bit that's answering the question) in a single `