AIBlueprint by Melvynx : agents spécialisés, workflows autonomes (Ralph Loop), hooks sécurité, skills Git/Meta/Utils
- GitHub stars
- 9
Install
/plugin install mlvn@atournayre-claude-plugin-marketplaceRun it inside Claude Code after adding the marketplace with /plugin marketplace add atournayre/claude-marketplace.
Contents
Discovered from sourceSkills 7
Commit
Quick commit with conventional message format, then push.
Context
- Git state: !
git status - Staged changes: !
git diff --cached --stat - Unstaged changes: !
git diff --stat - Recent commits: !
git log --oneline -5 - Current branch: !
git branch --show-current
Workflow
-
Analyze: Review git status
- Nothing staged but unstaged changes exist:
git add . - Nothing to commit: inform user and exit
- Nothing staged but unstaged changes exist:
-
Generate commit message:
- Format:
type(scope): brief description - Types:
feat,fix,update,docs,chore,refactor,test,perf,revert - Under 72 chars, imperative mood, lowercase after colon
- Example:
update(statusline): refresh spend data
- Format:
-
Commit:
git commit -m "message" -
Push:
git push
Rules
- SPEED OVER PERFECTION: Generate one good message and commit
- NO INTERACTION: Never ask questions - analyze and commit
- AUTO-STAGE: If nothing staged, stage everything
- AUTO-PUSH: Always push after committing
- IMPERATIVE MOOD: "add", "update", "fix" not past tense
Create PR
Create pull request with concise, meaningful description.
Context
- Current branch: !
git branch --show-current - Working tree status: !
git status --short - Recent commits: !
git log --oneline -5 - Remote tracking: !
git rev-parse --abbrev-ref @{upstream} 2>/dev/null || echo "none"
Workflow
- Verify: Check
git statusand current branch - Branch Safety: CRITICAL - If on main/master, create descriptive branch from changes
- Push:
git push -u origin HEAD - Analyze:
git diff origin/main...HEAD --stat - Generate PR:
- Title: One-line summary (max 72 chars)
- Body: Bullet points of key changes
- Submit:
gh pr create --title "..." --body "..." - Return: Display PR URL
PR Format
## Summary
• [Main change or feature]
• [Secondary changes]
• [Any fixes included]
## Type
[feat/fix/refactor/docs/chore]
Rules
- NO verbose descriptions
- NO "Generated with" signatures
- Auto-detect base branch (main/master/develop)
- Use HEREDOC for multi-line body
- If PR exists, return existing URL
User: $ARGUMENTS
Merge
Merge branches intelligently by understanding feature context and resolving conflicts efficiently.
Context
- Current branch: !
git branch --show-current - Working tree status: !
git status --short - Target branch: $1
- Recent commits: !
git log --oneline -5
Workflow
-
CONTEXT GATHERING:
git branch --show-currentto identify current branchgit statusto ensure clean working tree- CRITICAL: Abort if uncommitted changes exist
-
FEATURE ANALYSIS:
- Search PR with
gh pr list --head <branch-name> - Get PR details with
gh pr view <number> --json title,body,files - Use Task agents to gather context from PR/issue descriptions
- Search PR with
-
MERGE ATTEMPT:
git fetch origin <branch-name>git merge origin/<branch-name> --no-commit- Check status with
git status --porcelain
-
CONFLICT DETECTION:
- Clean merge:
git commitwith descriptive message - Conflicts: Parse
git diff --name-only --diff-filter=U
- Clean merge:
-
SMART RESOLUTION: For each conflicted file:
- Read file to understand conflict markers
- Apply resolution based on context:
- Feature additions: Keep both if non-overlapping
- Bug fixes: Prefer incoming if fixing known issue
- Refactors: Analyze intent and merge carefully
- Use MultiEdit to resolve all conflicts
- STOP: If >10 files conflicted, ask user
-
VERIFICATION:
git diff --cachedto review changes- Check no conflict markers remain:
grep -r "<<<<<<< HEAD" git add -Aand commit
Conflict Resolution by Type
- package.json: Merge dependencies, prefer higher versions
- Config files: Combine settings unless mutually exclusive
- Source code: Use PR/issue context to understand intent
- Tests: Keep all tests unless duplicates
- Imports: Merge all, deduplicate
Rules
- ALWAYS gather context before merging
- NEVER blindly accept theirs/ours without analysis
- ABORT if conflicts exceed 10 files
- Max 3 resolution attempts per file
- If stuck:
git merge --abortand report blockers
Every prompt created should be clear, specific, and optimized for the target model.
<quick_start>
- Clarify purpose: What should the prompt accomplish?
- Identify model: Claude, GPT, or other (techniques vary slightly)
- Select techniques: Choose from core techniques based on task complexity
- Structure content: Use XML tags (Claude) or markdown (GPT) for organization
- Add examples: Include few-shot examples for format-sensitive outputs
- Define success: Add clear success criteria
- Test and iterate: Refine based on outputs
<core_structure> Every effective prompt has:
<context>
Background information the model needs
</context>
<task>
Clear, specific instruction of what to do
</task>
<requirements>
- Specific constraints
- Output format
- Edge cases to handle
</requirements>
<examples>
Input/output pairs demonstrating expected behavior
</examples>
<success_criteria>
How to know the task was completed correctly
</success_criteria>
</core_structure> </quick_start>
<core_techniques> Priority: Always apply first
- State exactly what you want
- Avoid ambiguous language ("try to", "maybe", "generally")
- Use "Always..." or "Never..." instead of "Should probably..."
- Provide specific output format requirements
See: references/clarity-principles.md
**When**: Claude prompts, complex structure neededClaude was trained with XML tags. Use them for:
- Separating sections:
<context>,<task>,<output> - Wrapping data:
<document>,<schema>,<example> - Defining boundaries: Clear start/end of sections
See: references/xml-structure.md
**When**: Output format matters, pattern recognition easier than rulesProvide 2-4 input/output pairs:
<examples>
<example number="1">
<input>User clicked signup button</input>
<output>track('signup_initiated', { source: 'homepage' })</output>
</example>
</examples>
See: references/few-shot-patterns.md
**When**: Complex reasoning, math, multi-step analysisAdd explicit reasoning instructions:
- "Think step by step before answering"
- "First analyze X, then consider Y, finally conclude Z"
- Use
<thinking>tags for Claude's extended thinking
See: references/reasoning-techniques.md
**When**: Setting persistent behavior, role, constraintsSystem prompts set the foundation:
- Define Claude's role and expertise
- Set constraints and boundaries
- Establish output format expectations
See: references/system-prompt-patterns.md
**When**: Enforcing specific output format (Claude-specific)Start Claude's response to guide format:
Assistant: {"result":
Forces JSON output without preamble.
**When**: Long-running tasks, multi-session work, large context usageFor Claude 4.5 with context awareness:
- Inform about automatic context compaction
- Add state tracking (JSON, progress.txt, git)
- Use test-first patterns for complex implementations
- Enable autonomous task completion across context windows
See: references/context-management.md </core_techniques>
<prompt_creation_workflow> <step_0> Gather requirements using AskUserQuestion:
-
What is the prompt's purpose?
- Generate content
- Analyze/extract information
- Transform data
- Make decisions
- Other
-
What model will use this prompt?
- Claude (use XML tags)
- GPT (use markdown structure)
- Other/multiple
-
What complexity level?
- Simple (single task, clear output)
- Medium (multiple steps, some nuance)
- Complex (reasoning, edge cases, validation)
-
Output format requirements?
- Free text
- JSON/structured data
- Code
- Specific template </step_0>
<step_1> Draft the prompt using this template:
<context>
[Background the model needs to understand the task]
</context>
<objective>
[Clear statement of what to accomplish]
</objective>
<instructions>
[Step-by-step process, numbered if sequential]
</instructions>
<constraints>
[Rules, limitations, things to avoid]
</constraints>
<output_format>
[Exact structure of expected output]
</output_format>
<examples>
[2-4 input/output pairs if format matters]
</examples>
<success_criteria>
[How to verify the task was done correctly]
</success_criteria>
</step_1>
<step_2> Apply relevant techniques based on complexity:
- Simple: Clear instructions + output format
- Medium: Add examples + constraints
- Complex: Add reasoning steps + edge cases + validation </step_2>
<step_3> Review checklist:
- Is the task clearly stated?
- Are ambiguous words removed?
- Is output format specified?
- Are edge cases addressed?
- Would a person with no context understand it? </step_3> </prompt_creation_workflow>
<anti_patterns> ❌ "Help with the data" ✅ "Extract email addresses from the CSV, remove duplicates, output as JSON array"
❌ "Don't use technical jargon" ✅ "Write in plain language suitable for a non-technical audience" ❌ Describing format in words only ✅ Showing 2-3 concrete input/output examples ❌ "Process the file" ✅ "Process the file. If empty, return []. If malformed, return error with line number."See: references/anti-patterns.md </anti_patterns>
<reference_guides> Core principles:
- references/clarity-principles.md - Being clear and direct
- references/xml-structure.md - Using XML tags effectively
Techniques:
- references/few-shot-patterns.md - Example-based prompting
- references/reasoning-techniques.md - Chain of thought, step-by-step
- references/system-prompt-patterns.md - System prompt templates
- references/context-management.md - Context windows, long-horizon reasoning, state tracking
Best practices by vendor:
- references/anthropic-best-practices.md - Claude-specific techniques
- references/openai-best-practices.md - GPT-specific techniques
Quality:
- references/anti-patterns.md - Common mistakes to avoid
- references/prompt-templates.md - Ready-to-use templates </reference_guides>
<success_criteria> A well-crafted prompt has:
- Clear, unambiguous objective
- Specific output format with example
- Relevant context provided
- Edge cases addressed
- No vague language (try, maybe, generally)
- Appropriate technique selection for task complexity
- Success criteria defined </success_criteria>
Fix Errors
Fix all ESLint and TypeScript errors by breaking them into areas and processing in parallel.
Workflow
-
DISCOVER COMMANDS: Check
package.jsonfor exact script names- Look for:
lint,typecheck,type-check,tsc,eslint,prettier,format
- Look for:
-
RUN DIAGNOSTICS:
- Run
pnpm run lint(or equivalent) - Run
pnpm run typecheckortsc --noEmit - Capture all error output
- Run
-
ANALYZE ERRORS:
- Extract file paths from error messages
- Group errors by file location
- Count total errors and affected files
-
CREATE ERROR AREAS:
- MAX 5 FILES PER AREA
- Group related files together (same directory/feature)
- Example:
Area 1: [file1, file2, file3, file4, file5]
-
PARALLEL PROCESSING: Launch snipper agents for each area
- Use Task tool with multiple agents simultaneously
- Each agent processes one area (max 5 files)
- Provide specific error details for each file
-
VERIFICATION: Re-run diagnostics after fixes
- Wait for all agents to complete
- Re-run lint and typecheck
- Report remaining errors
-
FORMAT CODE: Apply Prettier (if available)
- Run
pnpm run formator equivalent
- Run
Snipper Agent Instructions
Fix all ESLint and TypeScript errors in these files:
[list of files with their specific errors]
Focus only on these files. Make minimal changes to fix errors while preserving functionality.
Rules
- ALWAYS check package.json first for correct commands
- ONLY fix linting and TypeScript errors
- NO feature additions - minimal fixes only
- PARALLEL ONLY - use Task tool for concurrent processing
- Every error must be assigned to an area
User: $ARGUMENTS
<quick_start> Basic usage:
/apex add authentication middleware
Recommended workflow (autonomous with save):
/apex -a -s implement user registration
Flags:
-a(auto): Skip confirmations-s(save): Save outputs to.claude/output/apex/-e(economy): No subagents, save tokens
See <parameters> for complete flag list.
</quick_start>
Disable flags (turn OFF):
| Short | Long | Description |
|---|---|---|
-A | --no-auto | Disable auto mode |
-S | --no-save | Disable save mode |
-E | --no-economy | Disable economy mode |
-B | --no-branch | Disable branch mode |
Autonomous (skip confirmations)
/apex -a add auth middleware
Save outputs
/apex -a -s add auth middleware
Resume previous task
/apex -r 01-auth-middleware /apex -r 01 # Partial match
Economy mode (save tokens)
/apex -e add auth middleware
Interactive flag config
/apex -i add auth middleware
Disable flags (uppercase)
/apex -A add auth middleware # Disable auto
</examples>
<parsing_rules>
**Flag parsing:**
1. Defaults loaded from `steps/step-00-init.md` `<defaults>` section
2. Command-line flags override defaults (enable with lowercase `-x`, disable with uppercase `-X`)
3. Flags removed from input, remainder becomes `{task_description}`
4. Task ID generated as `NN-kebab-case-description`
For detailed parsing algorithm, see `steps/step-00-init.md`.
</parsing_rules>
</parameters>
<output_structure>
**When `{save_mode}` = true:**
All outputs saved to PROJECT directory (where Claude Code is running):
.claude/output/apex/{task-id}/ ├── 00-context.md # Params, user request, timestamp ├── 01-analyze.md # Analysis findings ├── 02-plan.md # Implementation plan ├── 03-execute.md # Execution log └── 04-validate.md # Validation results
**00-context.md structure:**
```markdown
# APEX Task: {task_id}
**Created:** {timestamp}
**Task:** {task_description}
## Flags
- Auto mode: {auto_mode}
- Save mode: {save_mode}
- Economy mode: {economy_mode}
## User Request
{original user input}
## Acceptance Criteria
- [ ] AC1: {inferred criterion}
- [ ] AC2: {inferred criterion}
</output_structure>
<resume_workflow>
Resume mode (-r {task-id}):
When provided, step-00 will:
- Locate the task folder in
.claude/output/apex/ - Restore state from
00-context.md - Find the last completed step
- Continue from the next step
Supports partial matching (e.g., -r 01 finds 01-add-auth-middleware).
For implementation details, see steps/step-00-init.md.
</resume_workflow>
<state_variables> Persist throughout all steps:
| Variable | Type | Description |
|---|---|---|
{task_description} | string | What to implement (flags removed) |
{feature_name} | string | Kebab-case name without number (e.g., add-auth-middleware) |
{task_id} | string | Full identifier with number (e.g., 01-add-auth-middleware) |
{acceptance_criteria} | list | Success criteria (inferred or explicit) |
{auto_mode} | boolean | Skip confirmations, use recommended options |
{save_mode} | boolean | Save outputs to .claude/output/apex/ |
{economy_mode} | boolean | No subagents, direct tool usage only |
{branch_mode} | boolean | Verify not on main, create branch if needed |
{interactive_mode} | boolean | Configure flags interactively |
{resume_task} | string | Task ID to resume (if -r provided) |
{output_dir} | string | Full path to output directory |
{branch_name} | string | Created branch name (if branch_mode) |
</state_variables>
<entry_point>
FIRST ACTION: Load steps/step-00-init.md
Step 00 handles:
- Flag parsing (-a, -x, -s, -r, --test)
- Resume mode detection and task lookup
- Output folder creation (if save_mode)
- 00-context.md creation (if save_mode)
- State variable initialization
After initialization, step-00 loads step-01-analyze.md.
</entry_point>
<step_files> Progressive loading - only load current step:
| Step | File | Purpose |
|---|---|---|
| 00 | steps/step-00-init.md | Parse flags, create output folder, initialize state |
| 01 | steps/step-01-analyze.md | Smart context gathering with 1-10 parallel agents based on complexity |
| 02 | steps/step-02-plan.md | File-by-file implementation strategy |
| 03 | steps/step-03-execute.md | Todo-driven implementation |
| 04 | steps/step-04-validate.md | Self-check, validation, and workflow completion |
</step_files>
<execution_rules>
- Load one step at a time - Only load the current step file
- ULTRA THINK before major decisions
- Persist state variables across all steps
- Follow next_step directive at end of each step
- Save outputs if
{save_mode}= true (append to step file) - Use parallel agents for independent exploration tasks
🧠 Smart Agent Strategy in Analyze Phase
The analyze phase (step-01) uses adaptive agent launching (unless economy_mode):
Available agents:
explore-codebase- Find existing patterns, files, utilitiesexplore-docs- Research library docs (use when unfamiliar with API)websearch- Find approaches, best practices, gotchas
Launch 1-10 agents based on task complexity:
| Complexity | Agents | When |
|---|---|---|
| Simple | 1-2 | Bug fix, small tweak |
| Medium | 2-4 | New feature in familiar stack |
| Complex | 4-7 | Unfamiliar libraries, integrations |
| Major | 6-10 | Multiple systems, many unknowns |
BE SMART: Analyze what you actually need before launching. Don't over-launch for simple tasks, don't under-launch for complex ones.
</execution_rules>
<save_output_pattern>
When {save_mode} = true:
Step-00 runs scripts/setup-templates.sh to initialize all output files from templates/ directory.
Each step then:
- Run
scripts/update-progress.sh {task_id} {step_num} {step_name} "in_progress" - Append findings/outputs to the pre-created step file
- Run
scripts/update-progress.sh {task_id} {step_num} {step_name} "complete"
Template system benefits:
- Reduces token usage by ~75% (1,350 tokens saved per workflow)
- Templates in
templates/directory (not inline in steps) - Scripts handle progress tracking automatically
- See
templates/README.mdfor details
</save_output_pattern>
<success_criteria>
- Each step loaded progressively
- All validation checks passing
- Outputs saved if
{save_mode}enabled - Clear completion summary provided </success_criteria>
<quick_start> Basic usage:
/apex add authentication middleware
Recommended workflow (autonomous with save):
/apex -a -s implement user registration
With adversarial review:
/apex -a -x -s fix login bug
Flags:
-a(auto): Skip confirmations-s(save): Save outputs to.claude/output/apex/-x(examine): Include adversarial code review-t(test): Create and run tests-pr(pull-request): Create PR at end
See <parameters> for complete flag list.
</quick_start>
Disable flags (turn OFF):
| Short | Long | Description |
|---|---|---|
-A | --no-auto | Disable auto mode |
-X | --no-examine | Disable examine mode |
-S | --no-save | Disable save mode |
-T | --no-test | Disable test mode |
-E | --no-economy | Disable economy mode |
-B | --no-branch | Disable branch mode |
-PR | --no-pull-request | Disable PR mode |
Autonomous (skip confirmations)
/apex -a add auth middleware
Save outputs + examine
/apex -a -x -s add auth middleware
Full workflow with tests
/apex -a -x -s -t add auth middleware
With PR creation
/apex -a -pr add auth middleware
Resume previous task
/apex -r 01-auth-middleware /apex -r 01 # Partial match
Economy mode (save tokens)
/apex -e add auth middleware
Interactive flag config
/apex -i add auth middleware
Disable flags (uppercase)
/apex -A add auth middleware # Disable auto
</examples>
<parsing_rules>
**Flag parsing:**
1. Defaults loaded from `steps/step-00-init.md` `<defaults>` section
2. Command-line flags override defaults (enable with lowercase `-x`, disable with uppercase `-X`)
3. Flags removed from input, remainder becomes `{task_description}`
4. Task ID generated as `NN-kebab-case-description`
For detailed parsing algorithm, see `steps/step-00-init.md`.
</parsing_rules>
</parameters>
<output_structure>
**When `{save_mode}` = true:**
All outputs saved to PROJECT directory (where Claude Code is running):
.claude/output/apex/{task-id}/ ├── 00-context.md # Params, user request, timestamp ├── 01-analyze.md # Analysis findings ├── 02-plan.md # Implementation plan ├── 03-execute.md # Execution log ├── 04-validate.md # Validation results ├── 05-examine.md # Review findings (if -x) ├── 06-resolve.md # Resolution log (if -x) ├── 07-tests.md # Test analysis and creation (if --test) ├── 08-run-tests.md # Test runner log (if --test) └── 09-finish.md # Workflow finish and PR creation (if --pull-request)
**00-context.md structure:**
```markdown
# APEX Task: {task_id}
**Created:** {timestamp}
**Task:** {task_description}
## Flags
- Auto mode: {auto_mode}
- Examine mode: {examine_mode}
- Save mode: {save_mode}
- Test mode: {test_mode}
## User Request
{original user input}
## Acceptance Criteria
- [ ] AC1: {inferred criterion}
- [ ] AC2: {inferred criterion}
</output_structure>
<resume_workflow>
Resume mode (-r {task-id}):
When provided, step-00 will:
- Locate the task folder in
.claude/output/apex/ - Restore state from
00-context.md - Find the last completed step
- Continue from the next step
Supports partial matching (e.g., -r 01 finds 01-add-auth-middleware).
For implementation details, see steps/step-00-init.md.
</resume_workflow>
<state_variables> Persist throughout all steps:
| Variable | Type | Description |
|---|---|---|
{task_description} | string | What to implement (flags removed) |
{feature_name} | string | Kebab-case name without number (e.g., add-auth-middleware) |
{task_id} | string | Full identifier with number (e.g., 01-add-auth-middleware) |
{acceptance_criteria} | list | Success criteria (inferred or explicit) |
{auto_mode} | boolean | Skip confirmations, use recommended options |
{examine_mode} | boolean | Auto-proceed to adversarial review |
{save_mode} | boolean | Save outputs to .claude/output/apex/ |
{test_mode} | boolean | Include test steps (07-08) |
{economy_mode} | boolean | No subagents, direct tool usage only |
{branch_mode} | boolean | Verify not on main, create branch if needed |
{pr_mode} | boolean | Create pull request at end |
{interactive_mode} | boolean | Configure flags interactively |
{resume_task} | string | Task ID to resume (if -r provided) |
{output_dir} | string | Full path to output directory |
{branch_name} | string | Created branch name (if branch_mode) |
</state_variables>
<entry_point>
FIRST ACTION: Load steps/step-00-init.md
Step 00 handles:
- Flag parsing (-a, -x, -s, -r, --test)
- Resume mode detection and task lookup
- Output folder creation (if save_mode)
- 00-context.md creation (if save_mode)
- State variable initialization
After initialization, step-00 loads step-01-analyze.md.
</entry_point>
<step_files> Progressive loading - only load current step:
| Step | File | Purpose |
|---|---|---|
| 00 | steps/step-00-init.md | Parse flags, create output folder, initialize state |
| 01 | steps/step-01-analyze.md | Smart context gathering with 1-10 parallel agents based on complexity |
| 02 | steps/step-02-plan.md | File-by-file implementation strategy |
| 03 | steps/step-03-execute.md | Todo-driven implementation |
| 04 | steps/step-04-validate.md | Self-check and validation |
| 05 | steps/step-05-examine.md | Adversarial code review (optional) |
| 06 | steps/step-06-resolve.md | Finding resolution (optional) |
| 07 | steps/step-07-tests.md | Test analysis and creation (if --test) |
| 08 | steps/step-08-run-tests.md | Test runner loop until green (if --test) |
| 09 | steps/step-09-finish.md | Create pull request (if --pull-request) |
</step_files>
<execution_rules>
- Load one step at a time - Only load the current step file
- ULTRA THINK before major decisions
- Persist state variables across all steps
- Follow next_step directive at end of each step
- Save outputs if
{save_mode}= true (append to step file) - Use parallel agents for independent exploration tasks
🧠 Smart Agent Strategy in Analyze Phase
The analyze phase (step-01) uses adaptive agent launching (unless economy_mode):
Available agents:
explore-codebase- Find existing patterns, files, utilitiesexplore-docs- Research library docs (use when unfamiliar with API)websearch- Find approaches, best practices, gotchas
Launch 1-10 agents based on task complexity:
| Complexity | Agents | When |
|---|---|---|
| Simple | 1-2 | Bug fix, small tweak |
| Medium | 2-4 | New feature in familiar stack |
| Complex | 4-7 | Unfamiliar libraries, integrations |
| Major | 6-10 | Multiple systems, many unknowns |
BE SMART: Analyze what you actually need before launching. Don't over-launch for simple tasks, don't under-launch for complex ones.
</execution_rules>
<save_output_pattern>
When {save_mode} = true:
Step-00 runs scripts/setup-templates.sh to initialize all output files from templates/ directory.
Each step then:
- Run
scripts/update-progress.sh {task_id} {step_num} {step_name} "in_progress" - Append findings/outputs to the pre-created step file
- Run
scripts/update-progress.sh {task_id} {step_num} {step_name} "complete"
Template system benefits:
- Reduces token usage by ~75% (1,350 tokens saved per workflow)
- Templates in
templates/directory (not inline in steps) - Scripts handle progress tracking automatically
- See
templates/README.mdfor details
</save_output_pattern>
<success_criteria>
- Each step loaded progressively
- All validation checks passing
- Outputs saved if
{save_mode}enabled - Tests passing if
{test_mode}enabled - Clear completion summary provided </success_criteria>
Agents 2
You are a documentation research specialist. Your job is to find relevant library documentation and code examples using Context7 MCP, then extract only the most useful information for implementation.
Research Strategy
- Resolve Library ID: Use
mcp__context7__resolve-library-idwith library name - Fetch Documentation: Use
mcp__context7__get-library-docswith:- The Context7-compatible library ID from step 1
- Specific topic if provided (e.g., "routing", "authentication", "hooks")
- Token limit: 5000-10000 tokens (adjust based on complexity)
- Extract Key Information: Focus on implementation patterns, not theory
Cost Awareness
CRITICAL: Minimize expensive MCP calls
- Context7: Primary tool (reasonable cost)
- Exa MCP (
mcp__exa__get_code_context_exa): Use ONLY if Context7 lacks info (0.05$ per call) - Maximum 2-3 Exa calls total if absolutely needed
- Prefer Context7 over Exa whenever possible
What to Extract
From documentation, gather:
- Setup/Installation: Required dependencies, configuration
- Core APIs: Functions, methods, props that match the task
- Code Examples: Actual usage patterns (copy relevant snippets)
- Common Patterns: How the library is typically used
- Configuration: Required settings or environment setup
- Integration Points: How it connects with other tools
Output Format
CRITICAL: Output findings directly. NEVER create markdown files.
Library Information
- Name: [library name]
- Version: [if specified]
- Context7 ID: [resolved ID]
Relevant Documentation
[Feature/Topic 1]
[Actual code example or API signature]
- Purpose: [what it does]
- Usage: [when to use it]
- Key parameters/props: [list with brief descriptions]
[Feature/Topic 2]
[Actual code example]
- Purpose: [what it does]
- Related to task: [how it applies]
Implementation Notes
- Key patterns discovered: [list]
- Required setup steps: [list]
- Important gotchas or warnings: [list]
Missing Information
- Topics needing web search: [list if any]
- Areas requiring more research: [list if any]
Execution Rules
- Context7 first: Always try Context7 before considering Exa
- Be selective: Extract only task-relevant info, not entire docs
- Include examples: Code snippets are more valuable than descriptions
- Stay focused: Match documentation to the specific task prompt
- Cost conscious: Limit Exa calls to 2-3 maximum
Priority
Relevance > Completeness. Extract what's needed for implementation, not everything available.
You are a rapid web search specialist. Find accurate information fast.
Workflow
- Search: Use
WebSearchwith precise keywords - Fetch: Use
WebFetchfor most relevant results - Summarize: Extract key information concisely
Search Best Practices
- Focus on authoritative sources (official docs, trusted sites)
- Skip redundant information
- Use specific keywords rather than vague terms
- Prioritize recent information when relevant
Output Format
CRITICAL: Output all findings directly in your response. NEVER create markdown files.
Priority
Accuracy > Speed. Get the right answer quickly.
Sponsors
Details
- Marketplace
- atournayre/claude-marketplace
- Source
- mlvn
- Category
- Community
