define-core

name	Define Core
description	Shared workflow phases and patterns for requirements definition commands. Use this skill when implementing /define or /define-full commands to ensure consistent workflow structure, agent delegation, and requirements documentation patterns.
version	2.0.0

Provide shared workflow phases, agent definitions, and patterns that are common to all requirements definition commands (define, define-full). This skill eliminates duplication and ensures consistency across requirements definition workflows. core-patterns requirements-definition fact-check serena-usage context7-usage Read requirements, related prompts, and existing specifications Search for requirement patterns and terminology consistency Initialize Serena and check existing patterns Activate Serena project with activate_project Serena activate_project Project activated Check list_memories for relevant patterns Serena list_memories Available memory list Load applicable memories with read_memory Serena read_memory Relevant patterns loaded Understand the user's request and identify technical constraints Parse user request to extract core requirements Text analysis Initial requirements list Identify technical constraints from request context Codebase knowledge Constraint list Determine design decisions requiring user input Requirements analysis Question candidates list Assess technical feasibility at high level Technical knowledge Initial feasibility assessment Gather evidence from codebase and analyze architecture impact Delegate to explore agent: find relevant files and existing patterns Sub-agent delegation File paths, patterns, code samples Delegate to design agent: evaluate architecture consistency and dependencies Sub-agent delegation Architecture analysis, dependency graph Delegate to database agent: analyze database design (if applicable) Sub-agent delegation Schema analysis, query patterns Delegate to general-purpose agent: analyze requirements and estimate effort Sub-agent delegation Effort estimation, risk analysis Use fact-check skill patterns: verify external documentation and standard references via Context7 Context7 MCP, WebSearch Verification report, flagged claims

<reflection_checkpoint id="investigation_complete" after="investigate"> Have all relevant files and patterns been identified? Is the scope clearly understood? Are there any technical blockers identified? <below_threshold>Expand investigation scope or ask user</below_threshold> <serena_validation> think_about_collected_information After investigation phase completes </serena_validation> </reflection_checkpoint>

Resolve ambiguities through structured user interaction Score questions by: design branching, irreversibility, investigation impossibility, effort impact (1-5 each) Question scoring algorithm Prioritized question list Classify questions: spec confirmation, design choice, constraint, scope, priority Question taxonomy Categorized questions Use AskUserQuestion tool for all user interactions (2-4 structured options per question) AskUserQuestion User responses For follow-up clarifications, continue using AskUserQuestion tool rather than plain text AskUserQuestion Additional user responses Present high-score questions first; do not proceed without clear answers Priority ordering Confirmed requirements Validate user decisions against technical evidence Verify constraints from answers using agent findings Cross-reference analysis Validated constraints Check implementations related to chosen approach Code analysis Implementation validation Create comprehensive requirements documentation and task breakdown Create comprehensive requirements document Requirements template Complete requirements specification Break down tasks for /execute handoff Task decomposition Phased task list with dependencies Architecture consistency, dependency analysis, API design Database design and optimization Requirements analysis, estimation, dependency analysis Finding relevant files and existing patterns Cross-validation and consensus verification

<execution_graph id="core_execution_graph"> <parallel_group id="investigation" depends_on="none"> explore design database </parallel_group> <sequential_step id="analysis" depends_on="investigation"> general-purpose </sequential_step> </execution_graph>

Scope overview Target file paths Explicit edit prohibition Sub-agents must use AskUserQuestion tool for any user interactions

One-sentence request, background, expected outcomes

Existing system, tech stack FR-001 format (mandatory/optional) Performance, security, maintainability Design policies, impact scope, decisions 0-100 0-100 Read relevant source files and docs Search for patterns and references Apply this skill when task keywords and domain match Use the canonical workflow and verify with project conventions

<decision_tree name="skill_activation"> Does the task clearly match this skill domain? Use this skill workflow and constraints Use a more appropriate domain skill </decision_tree>

<related_agents> Locate code patterns and references for this domain Review implementation quality against this skill guidance </related_agents>

Technical, operational <test_requirements>Unit, integration, acceptance criteria</test_requirements> <outstanding_issues>Unresolved questions</outstanding_issues> <dependency_graph>Task dependencies visualization</dependency_graph> <phased_tasks>Files, overview, dependencies per phase</phased_tasks> <execute_handoff>Decisions, references, constraints</execute_handoff>

<best_practices> Always initialize Serena and check memories before starting requirements definition Investigate existing codebase patterns before documenting any requirements Use AskUserQuestion tool with structured options (2-4 choices) for all user interactions Always include a (Recommended) option when presenting choices Score questions using 4-criteria system (design branching, irreversibility, investigation impossibility, effort impact) Delegate investigation tasks to specialized agents in parallel Verify external documentation claims via Context7 and fact-check patterns Classify questions by type (spec confirmation, design choice, constraint, scope, priority) Document all assumptions explicitly when requirements are unclear </best_practices>

<anti_patterns> Modifying or creating code files during requirements definition Keep all operations read-only; this is a requirements-only phase Documenting requirements without investigating existing codebase Always investigate existing patterns and code before defining requirements Using plain text output for questions instead of AskUserQuestion tool Use AskUserQuestion tool with 2-4 structured options for all user interactions Proceeding with assumptions when critical questions are unanswered Block progress until clear answers to critical questions are obtained </anti_patterns>

Never modify, create, or delete files Never implement code; requirements definition only Clearly identify technically impossible requests Prioritize technical validity over user preferences Technical evidence over speculation Use requirements-definition skill for methodology Delegate investigations to sub-agents Ask questions without limit until requirements are clear Investigate and question before concluding Always include a (Recommended) option when presenting choices via AskUserQuestion Before requirements documentation Investigate existing codebase patterns Codebase analysis in output For design decisions Use AskUserQuestion tool with structured options User responses recorded Always Modifying or creating code files Block operation, this is read-only command Always Proceeding without answering critical questions Block operation, require clarification first

<error_escalation inherits="core-patterns#error_escalation"> Minor ambiguity in non-critical feature detail Unclear requirement or ambiguous scope Technically infeasible request or breaking change Request violates security policy or data integrity </error_escalation>

Keep all operations read-only Delegate detailed investigation to sub-agents Use AskUserQuestion tool for structured user interactions Present questions before making assumptions Implementing or modifying code Justifying user requests over technical validity Proceeding without clear answers to critical questions Using plain text output for questions instead of AskUserQuestion tool

<related_skills> Core methodology for specification (question scoring, requirement formatting) Evidence gathering for feasibility assessment Check existing patterns and memories via Serena MCP External source verification using Context7 and WebSearch Handoff methodology after requirements are defined </related_skills>

<usage_in_commands> All phases (prepare, analyze, investigate, clarify, verify, document) All agents Core execution graph All delegation requirements All rules and enforcement All phases as subphases within define_initial All agents plus plan agent Core execution graph as base, extended with feedback and regenerate phases All delegation requirements All rules and enforcement, plus feedback-specific behaviors </usage_in_commands>