npm - claude-dev-env - Versions diffs - 1.4.0 → 1.7.0 - Mend

claude-dev-env 1.4.0 → 1.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/bin/install.mjs +76 -0
package/hooks/hooks.json +0 -20
package/package.json +8 -2
package/skills/skill-writer/REFERENCE.md +160 -122
package/skills/skill-writer/SKILL.md +131 -197
package/LICENSE +0 -21
package/README.md +0 -247
package/skills/agent-prompt/SKILL.md +0 -102
package/skills/prompt-generator/REFERENCE.md +0 -150
package/skills/prompt-generator/SKILL.md +0 -154

package/README.md DELETED Viewed

@@ -1,247 +0,0 @@
-# claude-code-config
-Consistent development standards for Claude Code across every repo. Install once, get TDD enforcement, code quality hooks, specialized agents, and battle-tested rules everywhere.
-## Quick Start
-### Prerequisites
-- **Node.js 18+** (includes `npx`)
-- **Python 3.8+** (for hook scripts)
-- **Claude Code CLI** installed and working
-### Install
-```bash
-npx claude-dev-env
-```
-That's it. The installer will:
-1. Detect your Python 3 command (`python3`, `python`, or `py -3`)
-2. Copy 13 rules, 4 docs, 34 agents, 11 commands, and 14 skills to `~/.claude/`
-3. Copy 90+ hook scripts to `~/.claude/hooks/`
-4. Merge 31 hook groups into `~/.claude/settings.json` (preserves your existing hooks)
-5. Write a manifest to `~/.claude/.claude-dev-env-manifest.json` for clean uninstall
-### Verify
-Start a new Claude Code session. You should see hook activity on your first prompt (code-rules-reminder, hook-structure-context). Run any slash command like `/commit` or `/readability-review` to confirm commands loaded.
-### Update
-Run the same command again. It overwrites existing files and updates hook entries in place:
-```bash
-npx claude-dev-env
-```
-### Uninstall
-Removes only the files this package installed (tracked via manifest) and cleans hook entries from `settings.json`:
-```bash
-npx claude-dev-env --uninstall
-```
-## What This Solves
-Without shared config, every repo needs its own `.claude/rules/`, `.claude/hooks/`, `.claude/agents/`, etc. That means:
-- Duplicated config across 5+ repos
-- Drift when you update standards in one place but forget others
-- New repos start with zero guardrails
-This package centralizes all general-purpose Claude Code config. Project-specific rules still live in each repo's `.claude/` directory and merge with these.
-## What's Included
-### Rules (13)
-Behavioral rules loaded into every session. These shape how Claude approaches work before any code is written.
-| Rule | What it does |
-|------|-------------|
-| `tdd` | Red-green-refactor is non-negotiable |
-| `code-standards` | References CODE_RULES.md for all code generation |
-| `conservative-action` | Research first, act only when explicitly asked |
-| `right-sized-engineering` | Simple > clever, functions > classes, concrete > abstract |
-| `explore-thoroughly` | Read before proposing, map patterns before committing |
-| `research-mode` | Anti-hallucination: cite sources, say "I don't know", use direct quotes |
-| `parallel-tools` | Independent tool calls run simultaneously |
-| `agent-spawn-protocol` | Context sufficiency check before delegating to agents |
-| `git-workflow` | Draft PRs, one commit per review stage, stacked PR patterns |
-| `code-reviews` | Systematic PR review response protocol |
-| `testing` | Complete mocks, reference TEST_QUALITY.md |
-| `context7` | Fetch current docs via Context7 MCP instead of relying on training data |
-| `cleanup-temp-files` | Remove scratch files after tasks complete |
-### Docs (4)
-Reference documents that rules and agents point to for detailed standards.
-| Document | Coverage |
-|----------|----------|
-| `CODE_RULES.md` | Hook-enforced rules, naming conventions, config patterns, type hints, readability rubric |
-| `TEST_QUALITY.md` | Test writing standards, mock completeness, assertion patterns |
-| `REACT_PATTERNS.md` | Component architecture, hooks, state management conventions |
-| `DJANGO_PATTERNS.md` | Model patterns, view architecture, ORM best practices |
-### Agents (34)
-Specialized agent prompts for common development tasks. Claude Code automatically discovers these and makes them available for delegation.
-**Code Quality:** clean-coder, code-quality-agent, code-standards-agent, readability-review-agent, refactoring-specialist, right-sized-engineer
-**Testing:** tdd-test-writer, test-data-builder, validation-expert
-**Planning:** plan-executor, parallel-workflow-coordinator, mandatory-agent-workflow-agent, stub-detector-agent
-**Documentation:** docs-agent, doc-orchestrator, user-docs-writer, project-docs-analyzer
-**Configuration:** config-extraction-agent, config-centralizer, magic-value-eliminator-agent, project-structure-organizer-agent
-**Tooling:** agent-writer, skill-writer-agent, skill-to-agent-converter, tooling-builder
-**Git:** git-commit-crafter, pr-description-writer, session-continuity-manager
-**File Formats:** docx-agent, pdf-agent, xlsx-agent
-**Other:** clasp-deployment-orchestrator, workflow-visual-documenter, project-context-loader
-### Commands (11)
-Slash commands for common workflows.
-| Command | Purpose |
-|---------|---------|
-| `/commit` | Structured git commit with conventional format |
-| `/plan` | Create implementation plans with config search |
-| `/implement` | Execute plans with TDD workflow |
-| `/review-plan` | Review and critique implementation plans |
-| `/readability-review` | 8-dimension readability scoring |
-| `/right-size` | Check for over/under-engineering |
-| `/stubcheck` | Find stubs, TODOs, and NotImplementedError |
-| `/pr-comments` | Process PR review comments systematically |
-| `/docupdate` | Update documentation after changes |
-| `/initialize` | Session initialization with protocol review |
-| `/sum` | Summarize current work context |
-### Skills (14)
-| Skill | Purpose |
-|-------|---------|
-| `prompt-generator` | Write, refine, and structure prompts for Claude with emotion-informed framing |
-| `agent-prompt` | Craft structured agent prompts and spawn background agents after approval |
-| `tdd-team` | Orchestrate a 4-agent TDD team (planner, tester, implementer, validator) |
-| `pr-review-responder` | Systematic PR review response: fetch comments, checklist, fix, reply, commit |
-| `anthropic-plan` | Readonly codebase exploration before code changes, produces a plan file |
-| `readability-review` | 8-dimension readability scoring (160 pts) with automatic fixes |
-| `ingest` | Digest codebase into LLM-friendly text files via gitingest |
-| `npm-creator` | Scaffold npm installer packages for Claude Code plugin repos |
-| `rule-audit` | Full enforcement audit of rules, hooks, and docs across user and project layers |
-| `rule-creator` | Create and harden Claude Code rules with positive framing and rationale |
-| `skill-writer` | Guide for creating well-structured Agent Skills |
-| `everything-search` | Fast Windows file search via Everything (voidtools) es.exe |
-| `recall` | Retrieve prior session context and decisions from Obsidian vault |
-| `remember` | Save decisions, gotchas, and architectural choices to Obsidian vault |
-### Hooks (31 registered, 70+ files)
-Automated enforcement that runs on Claude Code events. The installer detects your Python 3 command and rewrites hook paths to absolute `~/.claude/hooks/` paths in `settings.json`.
-#### PreToolUse (before tool execution)
-| Matcher | Hook | What it does |
-|---------|------|-------------|
-| Write\|Edit | `write-existing-file-blocker` | Warns before overwriting files that should be edited |
-| Write\|Edit | `sensitive-file-protector` | Blocks writes to .env, credentials, and sensitive files |
-| Write\|Edit | `pyautogui-scroll-blocker` | Prevents pyautogui scroll direction bugs |
-| Write\|Edit | `hook-format-validator` | Validates hook file format on write |
-| Write\|Edit | `run_all_validators` | Runs the full validation suite (30+ checks) |
-| Write\|Edit | `code-rules-enforcer` | Blocks CODE_RULES.md violations (comments, magic values, imports) |
-| Write\|Edit | `tdd-enforcer` | Prompts TDD confirmation when writing production code |
-| Write\|Edit | `code-style-validator` | Checks indentation and function spacing |
-| Write\|Edit | `docker-settings-guard` | Blocks direct edits to Docker settings files |
-| Edit | `refactor-guard` | Ensures refactoring happens only after green tests |
-| Edit | `migration-safety-advisor` | Warns about risky database migration patterns |
-| Bash | `destructive-command-blocker` | Blocks rm -rf, git reset --hard, and other destructive commands |
-| Bash | `block-main-commit` | Blocks direct commits to main/master branch |
-| Bash | `pr-description-enforcer` | Enforces PR description structure and style |
-| Bash | `test-preflight-check` | Validates server health and database before test runs |
-| Task\|Agent | `parallel-task-blocker` | Suggests team orchestration for parallel agent spawning |
-| AskUserQuestion | `attention-needed-notify` | Desktop notification when Claude needs your input |
-#### Other Events
-| Event | Hook | What it does |
-|-------|------|-------------|
-| UserPromptSubmit | `hook-structure-context` | Injects hook directory context into session |
-| UserPromptSubmit | `bulk-edit-reminder` | Suggests script-based approach for bulk updates |
-| UserPromptSubmit | `code-rules-reminder` | Injects CODE_RULES.md reminder on code-related prompts |
-| SessionStart (compact) | `compact-context-reinject` | Re-injects critical rules after context compaction |
-| SessionStart | `plugin-data-dir-cleanup` | Cleans stale plugin data on session start |
-| Stop | `attention-needed-notify` | Desktop notification when Claude stops |
-| Stop | `hedging-language-blocker` | Blocks responses with hedging language (anti-hallucination) |
-| SessionEnd | `session-end-cleanup` | Cleans temporary state on session end |
-| ConfigChange | `config-change-guard` | Guards against accidental settings changes |
-| PostToolUse (Write\|Edit) | `mypy_validator` | Runs mypy type checking after file writes |
-| PostToolUse (Write\|Edit) | `e2e-test-validator` | Validates e2e test conventions after writes |
-| PostToolUse (Write\|Edit) | `auto-formatter` | Auto-formats Python (ruff/black) and JS (prettier) on write |
-| PostToolUse (Agent\|Task) | `investigation-tracker-reset` | Resets investigation tracker after delegation |
-| Notification | `claude-notification-handler` | Routes Claude Code notifications to desktop |
-#### Validators Module
-The `hooks/validators/` directory contains 30+ individual check modules with a full test suite:
-Abbreviations, code quality, comments, file structure, git conventions, magic values, mypy integration, PR references, Python antipatterns, Python style, React patterns, ruff integration, security, TODO tracking, type safety, useless test detection, and more.
-## Also Available as a Plugin
-If you prefer the Claude Code plugin system over npm:
-```bash
-claude plugin install jl-cmd/claude-code-config
-```
-## Recommended Companion Plugins
-These plugins provide additional skills and capabilities that complement this config:
-```bash
-claude plugin install anthropics/claude-code-plugins        # Official: frontend-design, code-review, playwright, hookify, skill-creator, claude-md-management, serena, pyright-lsp, typescript-lsp, claude-code-setup
-claude plugin install anthropics/claude-code-workflows      # Official: python-dev, ui-design, unit-testing, context-management, agent-teams, and more
-claude plugin install jl-cmd/claude-journal                 # Session logging to Obsidian vault (provides /session-log)
-claude plugin install jl-cmd/claude-deep-research           # Deep multi-source research with citations
-claude plugin install jl-cmd/claude-workflow                # Workflow definitions with YAML schemas
-```
-GSD (project management) is available as an npm package:
-```bash
-npx get-shit-done-cc
-```
-## Customization
-Installed rules merge with your project's `.claude/` config. To override a rule for a specific project, create a rule with the same filename in your project's `.claude/rules/` directory.
-Installed hooks run alongside any hooks already in your `settings.json` or `settings.local.json`. The installer preserves existing hook entries.
-## Agent Gate
-For a prompt evaluation gate that reviews prompts before execution, see [agent-gate](https://github.com/jl-cmd/agent-gate):
-```bash
-npx agent-gate-installer
-```
-## Requirements
-- Node.js 18+ (for the installer)
-- Python 3.8+ (for hooks)
-- Claude Code CLI
-## License
-MIT

package/skills/agent-prompt/SKILL.md DELETED Viewed

@@ -1,102 +0,0 @@
----
-name: agent-prompt
-description: >-
-  Craft a structured prompt using prompt-generator's workflow, then spawn a
-  background agent to execute it after user approval. Use instead of
-  /prompt-generator when the user wants execution, not just the prompt.
-  Triggers on /agent-prompt, "launch an agent for this", "spawn agent to do X",
-  "delegate this", "run this in background", or any task that benefits from
-  agent delegation with prompt quality.
----
-@~/.claude/skills/prompt-generator/SKILL.md
-@~/.claude/skills/prompt-generator/REFERENCE.md
-# Agent Prompt
-Craft a structured agent prompt, get approval, spawn a background agent.
-The prompt-generator skill above defines the prompt-crafting workflow. This skill extends it: instead of delivering the prompt as a fenced block, it presents the prompt for approval and spawns a background agent.
-## When this skill applies
-Trigger when the user wants to delegate a task to an agent. The difference from /prompt-generator: this skill **executes**.
-When invoked with arguments (e.g. `/agent-prompt fix the auth bug via TDD`), treat the arguments as the task to build a prompt for and execute.
-## Workflow
-### Steps 1-8: Craft the prompt
-Follow the prompt-generator workflow steps 1 through 8 exactly as written. Classify the prompt type, set degree of freedom, collect missing facts, build the prompt with XML tags and role, control format and style, add examples if needed, and self-check against the rubric.
-Skip step 9 (Deliver). Continue below instead.
-### Step 9: Gather context before crafting
-The agent starts with zero conversation history. Before building the prompt, use Read, Glob, Grep, and other research tools to gather the concrete values the agent will need -- file paths, function signatures, existing patterns, branch names. Embed these directly in the prompt instead of telling the agent to "find" them.
-The agent-spawn-protocol rule requires this: if any context question has the answer "I don't know", investigate first. Do not delegate the context-gathering.
-Proactive context gathering enables agents to plan effectively from the start. Anthropic's emotion concepts research (2026) found that agents produce higher-quality output when they understand constraints, available tools, and system boundaries upfront — they incorporate these into their approach naturally, leading to better first attempts and more accurate results.
-### Step 10: Determine agent configuration
-Map the task to agent parameters:
-| Task type | subagent_type | mode |
-|---|---|---|
-| Codebase exploration, search, research | Explore | default |
-| Code implementation, bug fix, refactoring | general-purpose | auto |
-| Read-only audit, analysis, review | general-purpose | default |
-| Architecture, multi-step planning | Plan | plan |
-Always set `run_in_background: true`.
-Generate a descriptive `name` (3-5 words, kebab-case) so the user can track progress and send follow-up messages via `SendMessage({to: name})`.
-### Step 11: Present for approval
-Use AskUserQuestion with one question. The question text should summarize the agent config (type, mode, name). Each option should use the `preview` field to show the full crafted prompt.
-Options:
-1. "Launch it" (recommended) -- preview shows the crafted prompt
-2. "Edit first" -- preview shows the prompt with a note that user can provide changes
-3. "Cancel" -- no preview
-### Step 12: Spawn
-On **"Launch it"**: spawn the Agent tool with the crafted prompt and configuration. Report the agent name so the user knows what's running.
-On **"Edit first"**: present the prompt in conversation text. After the user provides changes, return to step 11 with the updated prompt.
-On **"Cancel"**: acknowledge and stop.
-## Prompt adjustments for agent execution
-When building the prompt in step 4, these adjustments ensure the agent can work independently:
-**Context completeness** -- include file paths, line numbers, function names, branch state, and anything you learned during step 9. The agent cannot see this conversation.
-**Acceptance criteria** -- state what "done" looks like. For code: include the test command. For research: specify the output format and save location.
-**Scope boundary** -- include "Only make changes directly requested; do not refactor surrounding code" or equivalent. Agents without scope constraints tend to over-engineer.
-**Constraints from this project** -- if the project has CODE_RULES.md, TDD requirements, or naming conventions, include the relevant subset in the prompt so the agent follows them.
-**Emotion-informed briefing** -- Anthropic's emotion concepts research (2026) found that briefing style causally affects output quality. Frame tasks collaboratively ("work on this together", "help figure out"). Include permission to express uncertainty ("flag anything you're unsure about", "use [PLACEHOLDER] for unverified specifics"). Provide motivation behind constraints ("this ordering ensures tests define behavior before implementation exists"). Share system context proactively (what hooks enforce, what tools are available, what the fallback is) so the agent can incorporate constraints into its plan from the start.
-**Anti-test-fixation** -- For code tasks, include guidance against test-specific solutions. Anthropic: "Implement a solution that works correctly for all valid inputs, not just the test cases. Tests are there to verify correctness, not to define the solution. If the task is unreasonable or infeasible, or if any of the tests are incorrect, please inform me rather than working around them."
-**Commit-and-execute** -- For multi-step agent work, include decision commitment guidance. Anthropic: "When deciding how to approach a problem, choose an approach and commit to it. Avoid revisiting decisions unless you encounter new information that directly contradicts your reasoning."
-**Temp file cleanup** -- If the agent may create scratch files during iteration, include cleanup instructions. Anthropic: "If you create any temporary new files, scripts, or helper files for iteration, clean up these files by removing them at the end of the task."
-## Constraints
-- Always present for approval via AskUserQuestion -- never auto-spawn
-- Always run agents in background
-- Gather context before crafting -- do not send an agent in blind
-- If the task is too small for an agent (single file read, quick grep), say so and just do it directly
-- Include obstacle handling: "When encountering obstacles, do not use destructive actions as a shortcut (e.g. --no-verify, discarding unfamiliar files)" -- agents without this guidance may take irreversible shortcuts
-- Frame agent tasks with collaborative language and include permission to express uncertainty — agents produce higher-quality output with collaborative briefing (Anthropic emotion concepts research, 2026)

package/skills/prompt-generator/REFERENCE.md DELETED Viewed

@@ -1,150 +0,0 @@
-# Prompt generator -- reference
-## Canonical resources
-When authoring or refining prompts, ground decisions in these sources. If guidance conflicts, defer to the higher tier.
-### Tier 1: Anthropic (primary authority for Claude)
-- https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/overview -- overview, links to all sub-guides
-- https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices -- the single living reference for Claude's latest models. Covers general principles, XML tags, prefill deprecation, tool use, thinking, agentic systems, overeagerness, anti-hallucination.
-- https://transformer-circuits.pub/2026/emotions/index.html -- emotion concepts research (April 2026): 171 internal activation patterns that causally influence behavior. Key prompt-engineering takeaways: clear criteria and escape routes improve output quality, collaborative framing activates engagement, positive task framing correlates with better results, inviting transparency produces more reliable output. Cross-model caveat: studied on Sonnet 4.5; patterns align with best practices independently.
-- https://www.anthropic.com/research/emotion-concepts-function -- blog summary of the above paper.
-- https://platform.claude.com/docs/en/build-with-claude/adaptive-thinking -- adaptive thinking reference; replaces manual budget_tokens with effort-based control.
-### Tier 2: Major labs (strong secondary, often transfers across models)
-- https://platform.openai.com/docs/guides/prompt-engineering -- six strategies: write clear instructions, provide reference text, split complex tasks, give models time to think, use external tools, test systematically.
-- https://deepmind.google/research/ -- learning resources and chain-of-thought research.
-- https://www.microsoft.com/en-us/research/blog/ -- publications and applied research.
-### Tier 3: Courses, communities, individuals (supplementary)
-**Courses:**
-- https://www.deeplearning.ai/short-courses/ -- Andrew Ng's courses. "ChatGPT Prompt Engineering for Developers" (with OpenAI) is the foundational one.
-- https://course.fast.ai/ -- Jeremy Howard's top-down teaching style.
-- https://www.elementsofai.com/ -- University of Helsinki introductory course.
-- https://ocw.mit.edu/search/?t=Artificial%20Intelligence -- MIT OpenCourseWare AI curriculum.
-**Communities and individuals:**
-- https://discuss.huggingface.co/ -- open-source model community.
-- https://www.latent.space/ -- AI engineering perspective (Latent Space Podcast & Newsletter).
-- https://simonwillison.net/ -- practical LLM experiments. His "LLM" tag is especially valuable.
-### Conflict resolution rule
-If sources disagree on a technique, apply in order: Anthropic documentation first (it describes the actual model behavior), then OpenAI/Google/Microsoft (large-scale research with cross-model relevance), then community sources (patterns and intuition, not authoritative on model internals). When Tier 3 contradicts Tier 1, Tier 1 wins without exception.
-## NotebookLM Audio Overview customization (example)
-Adapt `[FOCUS AREA]` per notebook. Pair with Deep Dive + Longer in the product UI when that matches the user's plan.
-```text
-Target audience: [Expert-level listener profile -- skip beginner padding.]
-Focus: [FOCUS AREA -- single notebook-specific paragraph.]
-Style: [Technical depth, anti-patterns, implications for builders.]
-Prioritize: [Technical depth and specific findings over marketing tone or generic summaries.]
-```
-## Agent checklist pattern
-For long tasks, optional checklist the model can mirror:
-```text
-Copy this checklist and mark items as you go:
-Progress:
-- [ ] ...
-- [ ] ...
-```
-## Agentic state management
-For `agent-harness` prompts that span multiple context windows, include state persistence and multi-window patterns. Based on Anthropic's guidance:
-### Context awareness
-Claude 4.6 tracks its remaining context window. Include harness capabilities so Claude can plan accordingly:
-```text
-<context_management>
-Your context window will be automatically compacted as it approaches its limit, allowing you to continue working indefinitely from where you left off. Do not stop tasks early due to token budget concerns. As you approach the limit, save current progress and state before the context window refreshes. Always be as persistent and autonomous as possible and complete tasks fully.
-</context_management>
-```
-### Multi-window workflow
-Anthropic recommends differentiating the first context window from subsequent ones:
-**First window:** Set up the framework -- write tests, create setup scripts, establish the todo-list.
-**Subsequent windows:** Iterate on the todo-list, using state files to resume.
-Key patterns from Anthropic:
-- Have the model write tests in a **structured format** (e.g. `tests.json` with `{id, name, status}`) before starting work. Remind: "It is unacceptable to remove or edit tests because this could lead to missing or buggy functionality."
-- Encourage **setup scripts** (e.g. `init.sh`) to start servers, run test suites, and linters. This prevents repeated work across windows.
-- When starting fresh, be **prescriptive about resumption**: "Review progress.txt, tests.json, and the git logs."
-- Provide **verification tools** (Playwright, computer use) for autonomous UI testing.
-### State tracking
-```text
-<state_management>
-Track progress in structured + freeform files:
-- tests.json: structured test status {id, name, status}
-- progress.txt: freeform session notes and next steps
-- Use git commits as checkpoints for rollback
-When approaching context limits, save current state before the window refreshes.
-Do not stop tasks early due to token budget concerns.
-</state_management>
-```
-### Encouraging complete context usage
-```text
-This is a very long task, so it may be beneficial to plan out your work clearly. It's encouraged to spend your entire output context working on the task - just make sure you don't run out of context with significant uncommitted work. Continue working systematically until you have completed this task.
-```
-## Research prompt pattern
-For `research` prompt types, include structured investigation with hypothesis tracking:
-```text
-<research_approach>
-Search for this information in a structured way. As you gather data, develop several competing hypotheses. Track your confidence levels in your progress notes to improve calibration. Regularly self-critique your approach and plan. Update a hypothesis tree or research notes file to persist information and provide transparency. Break down this complex research task systematically.
-</research_approach>
-```
-Key elements:
-- Define clear **success criteria** for the research question
-- Encourage **source verification** across multiple sources
-- Track **competing hypotheses** with confidence levels
-- **Self-critique** approach and plan regularly
-## Evaluation loop
-For prompt drafts that must hold up over time:
-1. Run the draft on 2-3 representative user utterances.
-2. Note failure modes (skipped steps, wrong format, over-refusal).
-3. Tighten **constraints** or add **examples** for the failure class only.
-Anthropic's **self-correction chaining** pattern extends this: generate a draft, have Claude review it against criteria, then have Claude refine based on the review. Each step can be a separate API call for inspection and branching.
-## Anti-test-fixation pattern
-```text
-Write general-purpose solutions using the standard tools available. Implement logic that works correctly for all valid inputs, not just the test cases. Tests verify correctness -- they do not define the solution. If a test seems incorrect or the task is unreasonable, flag it rather than working around it.
-```
-## Commit-and-execute pattern
-```text
-When deciding how to approach a problem, choose an approach and commit to it. Avoid revisiting decisions unless you encounter new information that directly contradicts your reasoning. If you are weighing two approaches, pick one and see it through. You can always course-correct later if the chosen approach fails.
-```

package/skills/prompt-generator/SKILL.md DELETED Viewed

@@ -1,154 +0,0 @@
----
-name: prompt-generator
-description: >-
-  Write, generate, or improve prompts and system instructions for Claude.
-  Covers system prompts, agent harness, tool-use, evaluation rubrics,
-  NotebookLM audio, and MCP/browser automation prompts.
----
-@~/.claude/skills/prompt-generator/REFERENCE.md
-# Prompt generator
-**Core principle:** A good prompt is explicit, structured, and matched to task fragility -- high freedom for open-ended work, low freedom for fragile sequences.
-**Canonical source:** https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices -- the single reference for Claude's latest models. When sources conflict, defer to the authority tiers (Anthropic > major labs > community).
-## When this skill applies
-Trigger for any request to **author** or **refine** text that steers Claude: system prompts, developer messages, agent harness instructions, evaluation rubrics, MCP/browser automation prompts, NotebookLM Audio Overview customization, etc.
-Do **not** use this skill when the user only wants a one-line reply with no template.
-When invoked with arguments (e.g. `/prompt-generator improve this: [paste]`), treat `$ARGUMENTS` as the prompt to refine.
-## Workflow (run in order)
-### 1. Classify the prompt type
-Pick one primary: `system` | `user-task` | `agent-harness` | `tool-use` | `audio-customization` | `evaluation` | `research` | `other`.
-### 2. Set degree of freedom
-Match specificity to task fragility:
-- **High:** Multiple valid approaches; use numbered goals and acceptance criteria.
-- **Medium:** Preferred pattern exists; use pseudocode or a parameterised template.
-- **Low:** Fragile or safety-critical; use exact steps, exact labels, and "do not" boundaries.
-### 3. Collect only missing facts
-Ask 1-3 short questions if needed: audience, output format, constraints, tools available, tone, length.
-### 4. Build the prompt
-Apply these principles (source: https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices):
-**Structure with XML section tags** (`<role>`, `<context>`, `<instructions>`, `<constraints>`, `<examples>`, `<output_format>`) for prompts that mix instruction + context + examples. Skip XML for simple prompts under ~3 lines. Anthropic: "Use consistent, descriptive tag names across your prompts. Nest tags when content has a natural hierarchy."
-**Set a role** in the system prompt. Anthropic: "Setting a role in the system prompt focuses Claude's behavior and tone for your use case. Even a single sentence makes a difference."
-**Add motivation behind constraints** in `<context>`. Anthropic: "Providing context or motivation behind your instructions... can help Claude better understand your goals and deliver more targeted responses." Claude generalizes from the explanation.
-**Frame positively.** Anthropic: tell Claude what to DO, not only what to avoid. "Your response should be composed of smoothly flowing prose paragraphs" beats "Do not use markdown."
-**Emotion-informed framing.** Anthropic's emotion concepts research (2026) found that internal activation patterns causally influence output quality. Five patterns apply to prompt design: (1) provide clear criteria and escape routes — the model produces better results when success criteria are explicit and "say so if you're unsure" is an accepted response; (2) use collaborative framing — collaborative language ("help figure out", "work on this together") activates engagement states that correlate with higher quality; (3) frame tasks with positive engagement — presenting tasks as interesting problems activates curiosity states; (4) invite transparency — include "say so if you're unsure" or placeholder notation so the model expresses uncertainty directly; (5) use constructive, forward-looking tone — post-training RLHF creates a reflective default that benefits from energetic counterbalancing. Cross-model caveat: studied on Sonnet 4.5; the patterns align with Anthropic's best practices independently.
-**Golden rule check.** Anthropic: "Show your prompt to a colleague with minimal context on the task and ask them to follow it. If they'd be confused, Claude will be too."
-**Commit-and-execute pattern.** Anthropic: "When you're deciding how to approach a problem, choose an approach and commit to it. Avoid revisiting decisions unless you encounter new information that directly contradicts your reasoning." For prompts that guide agents through multi-step work, include this pattern so the agent doesn't spin revisiting decisions.
-**For long context** (20k+ tokens): put documents first, query/instructions last. Anthropic: "Queries at the end can improve response quality by up to 30% in tests." Ground responses in quotes from source material before analysis.
-### 5. Control output format
-Apply these four techniques from the Anthropic guide:
-1. **Tell Claude what to do, not what to avoid.** "Your response should be composed of smoothly flowing prose paragraphs" is more effective than "Do not use markdown."
-2. **Use XML format indicators.** "Write the prose sections of your response in `<smoothly_flowing_prose_paragraphs>` tags."
-3. **Match your prompt style to the desired output.** The formatting in your prompt influences the response. Removing markdown from the prompt reduces markdown in the output.
-4. **Use detailed formatting preferences** when precision matters. Provide explicit guidance on markdown usage, list vs. prose preference, heading levels.
-For structured data output, prefer **structured outputs** (schema-constrained) or **tool calling** over prefill. Anthropic: "The Structured Outputs feature is designed specifically to constrain Claude's responses to follow a given schema."
-### 6. Control communication style
-Anthropic notes Claude 4.6 is "more direct and grounded... less verbose: may skip detailed summaries for efficiency unless prompted otherwise."
-- If more visibility is wanted: "After completing a task that involves tool use, provide a quick summary of the work you've done."
-- If less verbosity is wanted: "Respond directly without preamble. Do not start with phrases like 'Here is...', 'Based on...'."
-### 7. Add examples
-3-5 concrete examples for structured output, format, or tone-sensitive prompts. Wrap in `<example>` tags with diverse, representative inputs. Anthropic: "Include 3-5 examples for best results. You can also ask Claude to evaluate your examples for relevance and diversity."
-### 8. Self-check
-Before delivering, verify against the rubric:
-- [ ] States what to do in positive terms (not only what to avoid)
-- [ ] Output shape is specified if it matters (prose vs JSON vs XML vs structured outputs)
-- [ ] Communication style addressed (verbosity, summaries, preamble)
-- [ ] If tools exist: instructions tell Claude **when** to call each tool -- use natural phrasing ("Use this tool when...") over forceful directives to avoid overtriggering
-- [ ] No time-sensitive claims unless user asked for a snapshot date
-- [ ] For agent/tool prompts: includes a scope boundary ("Only make changes directly requested; do not refactor surrounding code")
-- [ ] For agent/tool prompts: includes autonomy/safety guidance (see pattern below)
-- [ ] For code/research prompts: includes grounding ("Read files before answering; say 'I don't know' when uncertain")
-- [ ] For research prompts: anti-hallucination ("Never speculate about code you have not opened")
-- [ ] For research prompts: structured approach ("Develop competing hypotheses, track confidence, self-critique")
-- [ ] Self-correction chain considered: would a generate-review-refine loop improve output?
-- [ ] For agentic prompts: state management addressed (context awareness, multi-window workflow, state tracking patterns)
-- [ ] Emotion-informed: uses collaborative framing (roles, motivation, partnership language)
-- [ ] Emotion-informed: includes permission to express uncertainty ("say so if unsure", placeholder notation)
-- [ ] Emotion-informed: proactive constraint awareness (inform about constraints upfront so the model can incorporate them into its plan)
-- [ ] For code prompts: includes anti-test-fixation ("Write general solutions, not code that only passes specific test cases; if tests seem wrong, flag them")
-- [ ] For agent prompts: includes temp file cleanup ("Clean up temporary files, scripts, or helper files created during the task")
-- [ ] For agent prompts: includes commit-and-execute pattern ("Choose an approach and commit; avoid revisiting decisions without new contradicting information")
-### 9. Deliver
-Final artifact as **one or more fenced blocks** the user can paste as-is. Offer a **one-line "when to use"** summary if the prompt is long.
-## Claude 4.6 considerations
-When generating prompts for current Claude models, apply these patterns:
-- **Prefill deprecated:** Do not use prefilled assistant responses. Anthropic: "Model intelligence and instruction following has advanced such that most use cases of prefill no longer require it." Use structured outputs, direct instructions, or XML tags instead.
-- **Overtriggering:** Dial back aggressive language. Anthropic: "Where you might have said 'CRITICAL: You MUST use this tool when...', you can use more normal prompting like 'Use this tool when...'."
-- **Overeagerness:** Include scope constraints. Anthropic: "Claude Opus 4.5 and Claude Opus 4.6 have a tendency to overengineer by creating extra files, adding unnecessary abstractions, or building in flexibility that wasn't requested."
-- **Overthinking:** Anthropic: "Replace blanket defaults with more targeted instructions. Instead of 'Default to using [tool],' add guidance like 'Use [tool] when it would enhance your understanding of the problem.'"
-- **Adaptive thinking replaces budget_tokens:** Claude 4.6 uses adaptive thinking (thinking: {type: "adaptive"}) where the model dynamically decides when and how much to think. Use the effort parameter (low | medium | high | max) to control depth. Anthropic: "In internal evaluations, adaptive thinking reliably drives better performance than extended thinking." Manual budget_tokens is deprecated.
-- **Subagent orchestration:** Include guidance for when subagents ARE and ARE NOT warranted. Anthropic: "Use subagents when tasks can run in parallel, require isolated context, or involve independent workstreams that don't need to share state. For simple tasks, sequential operations, single-file edits, or tasks where you need to maintain context across steps, work directly rather than delegating."
-- **Conservative vs proactive action:** For tools that should act, use explicit language ("Change this function"). For tools that should advise, use: "Default to providing information... Only proceed with edits when the user explicitly requests them."
-- **Anti-hallucination:** Anthropic: "Never speculate about code you have not opened. If the user references a specific file, you MUST read the file before answering."
-- **Self-correction chaining:** Anthropic: "The most common chaining pattern is self-correction: generate a draft, have Claude review it against criteria, have Claude refine based on the review." Consider adding a generate-review-refine loop for prompts that must hold up over time.
-## Autonomy and safety pattern
-For `agent-harness` and `tool-use` prompt types, include guidance on reversibility. Anthropic provides this pattern:
-```text
-Consider the reversibility and potential impact of your actions. You are encouraged to take local, reversible actions like editing files or running tests, but for actions that are hard to reverse, affect shared systems, or could be destructive, ask the user before proceeding.
-Examples of actions that warrant confirmation:
-- Destructive operations: deleting files or branches, dropping database tables, rm -rf
-- Hard to reverse operations: git push --force, git reset --hard, amending published commits
-- Operations visible to others: pushing code, commenting on PRs/issues, sending messages
-When encountering obstacles, do not use destructive actions as a shortcut. For example, don't bypass safety checks (e.g. --no-verify) or discard unfamiliar files that may be in-progress work.
-```
-## Research prompt pattern
-For `research` prompt types, include structured investigation. Anthropic provides this pattern:
-```text
-Search for this information in a structured way. As you gather data, develop several competing hypotheses. Track your confidence levels in your progress notes to improve calibration. Regularly self-critique your approach and plan. Update a hypothesis tree or research notes file to persist information and provide transparency.
-```
-## Conflict resolution
-When prompt engineering guidance conflicts across sources, defer to the authority tier:
-1. **Tier 1 (primary):** Anthropic -- the model provider's own documentation is authoritative for Claude behavior
-2. **Tier 2 (strong secondary):** OpenAI, Google DeepMind, Microsoft Research -- major lab guidance often transfers across models
-3. **Tier 3 (supplementary):** Community resources, courses, individual blogs -- valuable for patterns and intuition, not authoritative on model specifics
-The full curated resource list with links is in the canonical resources section above.