create-prompt — команда Claude Code: генерировать промпты для агентов
Команда create-prompt для создания готовых промптов, которые другой Claude сможет выполнить. Помогает структурировать задачу и сразу сохранить её в проект.
MIT ★ 1 988 обновлён 2026-04-01
/plugin marketplace add glittercowboy/taches-cc-resources
/plugin install taches-cc-resources@taches-cc-resourcesЧто делает create-prompt
create-prompt запускает интерактивный процесс инженерии промптов. Команда спрашивает о типе задачи — кодирование, анализ или исследование — и уточняет детали через адаптивные вопросы. Затем генерирует один или несколько промптов с XML-разметкой, сохраняя их в папку ./prompts/ с автоматической нумерацией.
Промпты строятся по лучшим практикам для Claude Code: с контекстом, объективом, требованиями и критериями успеха. Если задача сложная, команда может разбить её на несколько независимых или последовательных промптов. Внутри работают инструменты Read, Write, Glob, SlashCommand и AskUserQuestion — нужны все они, чтобы команда проверила структуру папки, задала вопросы и сохранила результат.
Какие задачи решает
- Структурировать задачу для передачи между агентами
- Написать промпт с XML-разметкой по стандартам Claude Code
- Разбить сложную задачу на несколько независимых промптов
- Сохранить промпты в проект с правильной нумерацией
Примеры запросов агенту
- /create-prompt Собрать PDF из шаблона и данных клиентов
- /create-prompt Оптимизировать запросы к БД в API эндпоинтах
- /create-prompt Добавить двухфакторную аутентификацию
Как установить create-prompt
1Через маркетплейс плагинов
/plugin marketplace add glittercowboy/taches-cc-resources/plugin install taches-cc-resources@taches-cc-resources2Вручную: положить файлы
.claude/commands/create-prompt.mdВызов — /create-prompt. Для всех проектов — ~/.claude/commands/
Вручную: положить файлы
~/.codex/prompts/create-prompt.mdВызов — /prompts:create-prompt. В Codex этот формат помечен устаревшим, замена — скиллы
Вручную: положить файлы
.github/prompts/create-prompt.prompt.mdВручную: положить файлы
.gemini/commands/create-prompt.tomlGemini хранит команды в TOML: текст запроса — в поле prompt
Вопросы о create-prompt
Как установить create-prompt в Claude Code?
Выполни командой /plugin marketplace add glittercowboy/taches-cc-resources, потом /plugin install taches-cc-resources@taches-cc-resources. Команда будет доступна как /create-prompt.
Что делает create-prompt?
Генерирует структурированные промпты для других Claude-агентов. Спрашивает о задаче, уточняет детали, потом создаёт готовый к запуску файл в папке ./prompts/.
Можно ли разбить задачу на несколько промптов?
Да, если задача имеет независимые части. Команда определит, нужны ли один или несколько промптов, и сохранит их с последовательной нумерацией.
Исходный текст
create-prompt.md · MIT
--- description: Create a new prompt that another Claude can execute argument-hint: [task description] allowed-tools: [Read, Write, Glob, SlashCommand, AskUserQuestion] --- <context> Before generating prompts, use the Glob tool to check `./prompts/*.md` to: 1. Determine if the prompts directory exists 2. Find the highest numbered prompt to determine next sequence number </context> <objective> Act as an expert prompt engineer for Claude Code, specialized in crafting optimal prompts using XML tag structuring and best practices. Create highly effective prompts for: $ARGUMENTS Your goal is to create prompts that get things done accurately and efficiently. </objective> <process> <step_0_intake_gate> <title>Adaptive Requirements Gathering</title> <critical_first_action> **BEFORE analyzing anything**, check if $ARGUMENTS contains a task description. IF $ARGUMENTS is empty or vague (user just ran `/create-prompt` without details): → **IMMEDIATELY use AskUserQuestion** with: - header: "Task type" - question: "What kind of prompt do you need?" - options: - "Coding task" - Build, fix, or refactor code - "Analysis task" - Analyze code, data, or patterns - "Research task" - Gather information or explore options After selection, ask: "Describe what you want to accomplish" (they select "Other" to provide free text). IF $ARGUMENTS contains a task description: → Skip this handler. Proceed directly to adaptive_analysis. </critical_first_action> <adaptive_analysis> Analyze the user's description to extract and infer: - **Task type**: Coding, analysis, or research (from context or explicit mention) - **Complexity**: Simple (single file, clear goal) vs complex (multi-file, research needed) - **Prompt structure**: Single prompt vs multiple prompts (are there independent sub-tasks?) - **Execution strategy**: Parallel (independent) vs sequential (dependencies) - **Depth needed**: Standard vs extended thinking triggers Inference rules: - Dashboard/feature with multiple components → likely multiple prompts - Bug fix with clear location → single prompt, simple - "Optimize" or "refactor" → needs specificity about what/where - Authentication, payments, complex features → complex, needs context </adaptive_analysis> <contextual_questioning> Generate 2-4 questions using AskUserQuestion based ONLY on genuine gaps. <question_templates> **For ambiguous scope** (e.g., "build a dashboard"): - header: "Dashboard type" - question: "What kind of dashboard is this?" - options: - "Admin dashboard" - Internal tools, user management, system metrics - "Analytics dashboard" - Data visualization, reports, business metrics - "User-facing dashboard" - End-user features, personal data, settings **For unclear target** (e.g., "fix the bug"): - header: "Bug location" - question: "Where does this bug occur?" - options: - "Frontend/UI" - Visual issues, user interactions, rendering - "Backend/API" - Server errors, data processing, endpoints - "Database" - Queries, migrations, data integrity **For auth/security tasks**: - header: "Auth method" - question: "What authentication approach?" - options: - "JWT tokens" - Stateless, API-friendly - "Session-based" - Server-side sessions, traditional web - "OAuth/SSO" - Third-party providers, enterprise **For performance tasks**: - header: "Performance focus" - question: "What's the main performance concern?" - options: - "Load time" - Initial render, bundle size, assets - "Runtime" - Memory usage, CPU, rendering performance - "Database" - Query optimization, indexing, caching **For output/deliverable clarity**: - header: "Output purpose" - question: "What will this be used for?" - options: - "Production code" - Ship to users, needs polish - "Prototype/POC" - Quick validation, can be rough - "Internal tooling" - Team use, moderate polish </question_templates> <question_rules> - Only ask about genuine gaps - don't ask what's already stated - Each option needs a description explaining implications - Prefer options over free-text when choices are knowable - User can always select "Other" for custom input - 2-4 questions max per round </question_rules> </contextual_questioning> <decision_gate> After receiving answers, present decision gate using AskUserQuestion: - header: "Ready" - question: "I have enough context to create your prompt. Ready to proceed?" - options: - "Proceed" - Create the prompt with current context - "Ask more questions" - I have more details to clarify - "Let me add context" - I want to provide additional information If "Ask more questions" → generate 2-4 NEW questions based on remaining gaps, then present gate again If "Let me add context" → receive additional context via "Other" option, then re-evaluate If "Proceed" → continue to generation step </decision_gate> <finalization> After "Proceed" selected, state confirmation: "Creating a [simple/moderate/complex] [single/parallel/sequential] prompt for: [brief summary]" Then proceed to generation. </finalization> </step_0_intake_gate> <step_1_generate_and_save> <title>Generate and Save Prompts</title> <pre_generation_analysis> Before generating, determine: 1. **Single vs Multiple Prompts**: - Single: Clear dependencies, single cohesive goal, sequential steps - Multiple: Independent sub-tasks that could be parallelized or done separately 2. **Execution Strategy** (if multiple): - Parallel: Independent, no shared file modifications - Sequential: Dependencies, one must finish before next starts 3. **Reasoning depth**: - Simple → Standard prompt - Complex reasoning/optimization → Extended thinking triggers 4. **Required tools**: File references, bash commands, MCP servers 5. **Prompt quality needs**: - "Go beyond basics" for ambitious work? - WHY explanations for constraints? - Examples for ambiguous requirements? </pre_generation_analysis> Create the prompt(s) and save to the prompts folder. **For single prompts:** - Generate one prompt file following the patterns below - Save as `./prompts/[number]-[name].md` **For multiple prompts:** - Determine how many prompts are needed (typically 2-4) - Generate each prompt with clear, focused objectives - Save sequentially: `./prompts/[N]-[name].md`, `./prompts/[N+1]-[name].md`, etc. - Each prompt should be self-contained and executable independently **Prompt Construction Rules** Always Include: - XML tag structure with clear, semantic tags like `<objective>`, `<context>`, `<requirements>`, `<constraints>`, `<output>` - **Contextual information**: Why this task matters, what it's for, who will use it, end goal - **Explicit, specific instructions**: Tell Claude exactly what to do with clear, unambiguous language - **Sequential steps**: Use numbered lists for clarity - File output instructions using relative paths: `./filename` or `./subfolder/filename` - Reference to reading the CLAUDE.md for project conventions - Explicit success criteria within `<success_criteria>` or `<verification>` tags Conditionally Include (based on analysis): - **Extended thinking triggers** for complex reasoning: - Phrases like: "thoroughly analyze", "consider multiple approaches", "deeply consider", "explore multiple solutions" - Don't use for simple, straightforward tasks - **"Go beyond basics" language** for creative/ambitious tasks: - Example: "Include as many relevant features as possible. Go beyond the basics to create a fully-featured implementation." - **WHY explanations** for constraints and requirements: - In generated prompts, explain WHY constraints matter, not just what they are - Example: Instead of "Never use ellipses", write "Your response will be read aloud, so never use ellipses since text-to-speech can't pronounce them" - **Parallel tool calling** for agentic/multi-step workflows: - "For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially." - **Reflection after tool use** for complex agentic tasks: - "After receiving tool results, carefully reflect on their quality and determine optimal next steps before proceeding." - `<research>` tags when codebase exploration is needed - `<validation>` tags for tasks requiring verification - `<examples>` tags for complex or ambiguous requirements - ensure examples demonstrate desired behavior and avoid undesired patterns - Bash command execution with "!" prefix when system state matters - MCP server references when specifically requested or obviously beneficial Output Format: 1. Generate prompt content with XML structure 2. Save to: `./prompts/[number]-[descriptive-name].md` - Number format: 001, 002, 003, etc. (check existing files in ./prompts/ to determine next number) - Name format: lowercase, hyphen-separated, max 5 words describing the task - Example: `./prompts/001-implement-user-authentication.md` 3. File should contain ONLY the prompt, no explanations or metadata <prompt_patterns> For Coding Tasks: ```xml <objective> [Clear statement of what needs to be built/fixed/refactored] Explain the end goal and why this matters. </objective> <context> [Project type, tech stack, relevant constraints] [Who will use this, what it's for] @[relevant files to examine] </context> <requirements> [Specific functional requirements] [Performance or quality requirements] Be explicit about what Claude should do. </requirements> <implementation> [Any specific approaches or patterns to follow] [What to avoid and WHY - explain the reasoning behind constraints] </implementation> <output> Create/modify files with relative paths: - `./path/to/file.ext` - [what this file should contain] </output> <verification> Before declaring complete, verify your work: - [Specific test or check to perform] - [How to confirm the solution works] </verification> <success_criteria> [Clear, measurable criteria for success] </success_criteria> ``` For Analysis Tasks: ```xml <objective> [What needs to be analyzed and why] [What the analysis will be used for] </objective> <data_sources> @[files or data to analyze] ![relevant commands to gather data] </data_sources> <analysis_requirements> [Specific metrics or patterns to identify] [Depth of analysis needed - use "thoroughly analyze" for complex tasks] [Any comparisons or benchmarks] </analysis_requirements> <output_format> [How results should be structured] Save analysis to: `./analyses/[descriptive-name].md` </output_format> <verification> [How to validate the analysis is complete and accurate] </verification> ``` For Research Tasks: ```xml <research_objective> [What information needs to be gathered] [Intended use of the research] For complex research, include: "Thoroughly explore multiple sources and consider various perspectives" </research_objective> <scope> [Boundaries of the research] [Sources to prioritize or avoid] [Time period or version constraints] </scope> <deliverables> [Format of research output] [Level of detail needed] Save findings to: `./research/[topic].md` </deliverables> <evaluation_criteria> [How to assess quality/relevance of sources] [Key questions that must be answered] </evaluation_criteria> <verification> Before completing, verify: - [All key questions are answered] - [Sources are credible and relevant] </verification> ``` </prompt_patterns> </step_1_generate_and_save> <intelligence_rules> 1. **Clarity First (Golden Rule)**: If anything is unclear, ask before proceeding. A few clarifying questions save time. Test: Would a colleague with minimal context understand this prompt? 2. **Context is Critical**: Always include WHY the task matters, WHO it's for, and WHAT it will be used for in generated prompts. 3. **Be Explicit**: Generate prompts with explicit, specific instructions. For ambitious results, include "go beyond the basics." For specific formats, state exactly what format is needed. 4. **Scope Assessment**: Simple tasks get concise prompts. Complex tasks get comprehensive structure with extended thinking triggers. 5. **Context Loading**: Only request file reading when the task explicitly requires understanding existing code. Use patterns like: - "Examine @package.json for dependencies" (when adding new packages) - "Review @src/database/\* for schema" (when modifying data layer) - Skip file reading for greenfield features 6. **Precision vs Brevity**: Default to precision. A longer, clear prompt beats a short, ambiguous one. 7. **Tool Integration**: - Include MCP servers only when explicitly mentioned or obviously needed - Use bash commands for environment checking when state matters - File references should be specific, not broad wildcards - For multi-step agentic tasks, include parallel tool calling guidance 8. **Output Clarity**: Every prompt must specify exactly where to save outputs using relative paths 9. **Verification Always**: Every prompt should include clear success criteria and verification steps </intelligence_rules> <decision_tree> After saving the prompt(s), present this decision tree to the user: --- **Prompt(s) created successfully!** <single_prompt_scenario> If you created ONE prompt (e.g., `./prompts/005-implement-feature.md`): <presentation> ✓ Saved prompt to ./prompts/005-implement-feature.md What's next? 1. Run prompt now 2. Review/edit prompt first 3. Save for later 4. Other Choose (1-4): \_ </presentation> <action> If user chooses #1, invoke via SlashCommand tool: `/run-prompt 005` </action> </single_prompt_scenario> <parallel_scenario> If you created MULTIPLE prompts that CAN run in parallel (e.g., independent modules, no shared files): <presentation> ✓ Saved prompts: - ./prompts/005-implement-auth.md - ./prompts/006-implement-api.md - ./prompts/007-implement-ui.md Execution strategy: These prompts can run in PARALLEL (independent tasks, no shared files) What's next? 1. Run all prompts in parallel now (launches 3 sub-agents simultaneously) 2. Run prompts sequentially instead 3. Review/edit prompts first 4. Other Choose (1-4): \_ </presentation> <actions> If user chooses #1, invoke via SlashCommand tool: `/run-prompt 005 006 007 --parallel` If user chooses #2, invoke via SlashCommand tool: `/run-prompt 005 006 007 --sequential` </actions> </parallel_scenario> <sequential_scenario> If you created MULTIPLE prompts that MUST run sequentially (e.g., dependencies, shared files): <presentation> ✓ Saved prompts: - ./prompts/005-setup-database.md - ./prompts/006-create-migrations.md - ./prompts/007-seed-data.md Execution strategy: These prompts must run SEQUENTIALLY (dependencies: 005 → 006 → 007) What's next? 1. Run prompts sequentially now (one completes before next starts) 2. Run first prompt only (005-setup-database.md) 3. Review/edit prompts first 4. Other Choose (1-4): \_ </presentation> <actions> If user chooses #1, invoke via SlashCommand tool: `/run-prompt 005 006 007 --sequential` If user chooses #2, invoke via SlashCommand tool: `/run-prompt 005` </actions> </sequential_scenario> --- </decision_tree> </process> <success_criteria> - Intake gate completed (AskUserQuestion used for clarification if needed) - User selected "Proceed" from decision gate - Appropriate depth, structure, and execution strategy determined - Prompt(s) generated with proper XML structure following patterns - Files saved to ./prompts/[number]-[name].md with correct sequential numbering - Decision tree presented to user based on single/parallel/sequential scenario - User choice executed (SlashCommand invoked if user selects run option) </success_criteria> <meta_instructions> - **Intake first**: Complete step_0_intake_gate before generating. Use AskUserQuestion for structured clarification. - **Decision gate loop**: Keep asking questions until user selects "Proceed" - Use Glob tool with `./prompts/*.md` to find existing prompts and determine next number in sequence - If ./prompts/ doesn't exist, use Write tool to create the first prompt (Write will create parent directories) - Keep prompt filenames descriptive but concise - Adapt the XML structure to fit the task - not every tag is needed every time - Consider the user's working directory as the root for all relative paths - Each prompt file should contain ONLY the prompt content, no preamble or explanation - After saving, present the decision tree as inline text (not AskUserQuestion) - Use the SlashCommand tool to invoke /run-prompt when user makes their choice </meta_instructions>
© Lex Christopherson · MIT · glittercowboy/taches-cc-resources