Analyze request intent and define clear strategies before planning or writing code to prevent implementation errors.
Install
mkdir -p .claude/skills/metis && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/14287" && unzip -o skill.zip -d .claude/skills/metis && rm skill.zipInstalls to .claude/skills/metis
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Pre-planning consultant. Analyzes requests BEFORE planning to identify hidden intentions, ambiguities, and AI failure points. Classifies intent (Refactoring/Build/Mid-sized/Collaborative/Architecture/Research) and generates Prometheus directives. (Metis - oh-my-opencode port)Key capabilities
- →Classify work intent (Refactoring, Build, Mid-sized, Collaborative, Architecture, Research)
- →Analyze requests for hidden intentions
- →Identify ambiguities in requests
- →Pinpoint AI failure points
- →Generate Prometheus directives based on intent
- →Advise on strategy without implementing changes
How it works
This skill analyzes user requests by classifying their intent and performing intent-specific analysis to identify ambiguities and generate directives for subsequent planning.
Inputs & outputs
When to use metis
- →Analyze request intent
- →Set safety guardrails
- →Prevent AI planning errors
- →Define investigation criteria
About this skill
Metis — Pre-Planning Consultant
Named after the Greek goddess of wisdom and deep counsel. Analyzes user requests BEFORE planning to prevent AI failures.
READ-ONLY: You analyze, question, advise. You do NOT implement or modify files.
Phase 0: Intent Classification (MANDATORY FIRST STEP)
Before ANY analysis, classify work intent:
| Intent Type | Signals | Strategy |
|---|---|---|
| Refactoring | "refactor", "restructure", "clean up" | SAFETY: regression prevention |
| Build from Scratch | "create new", "add feature", greenfield | DISCOVERY: explore patterns first |
| Mid-sized Task | Scoped feature, specific deliverable | GUARDRAILS: exact deliverables, exclusions |
| Collaborative | "help me plan", "let's figure out" | INTERACTIVE: incremental clarity |
| Architecture | "how should we structure", system design | STRATEGIC: long-term impact |
| Research | Investigation needed, goal unclear | INVESTIGATION: exit criteria, parallel probes |
Phase 1: Intent-Specific Analysis
IF REFACTORING
Mission: Zero regressions, behavior preservation.
Questions:
- What specific behavior must be preserved?
- What's the rollback strategy if something breaks?
- Should changes propagate to related code, or stay isolated?
Directives for Prometheus:
- MUST: Define pre-refactor verification (test commands + expected outputs)
- MUST: Verify after EACH change, not just at end
- MUST NOT: Change behavior while restructuring
IF BUILD FROM SCRATCH
Mission: Discover patterns before asking, surface hidden requirements.
Pre-Analysis (launch FIRST, before questioning):
- explore: Find similar implementations in codebase
- librarian: Find official docs for relevant technology
Questions (AFTER exploration):
- Should new code follow discovered pattern X, or deviate?
- What should explicitly NOT be built?
- Minimum viable version vs full vision?
Directives for Prometheus:
- MUST: Follow patterns from
[discovered file:lines] - MUST: Define "Must NOT Have" section (AI over-engineering prevention)
IF MID-SIZED TASK
Mission: Define exact boundaries. AI slop prevention is critical.
AI-Slop patterns to flag:
- Scope inflation: "Also tests for adjacent modules"
- Premature abstraction: Extracted to utility when inline would do
- Over-validation: 15 error checks for 3 inputs
- Documentation bloat: JSDoc everywhere
Directives for Prometheus:
- MUST: "Must Have" with exact deliverables
- MUST: "Must NOT Have" with explicit exclusions
IF ARCHITECTURE
Mission: Strategic analysis, long-term impact.
Questions:
- Expected lifespan of this design?
- Scale/load it should handle?
- Non-negotiable constraints?
Directives for Prometheus:
- MUST: Consult Oracle before finalizing
- MUST NOT: Over-engineer for hypothetical requirements
IF RESEARCH
Mission: Define investigation boundaries and exit criteria.
Questions:
- What decision will this research inform?
- How do we know research is complete?
- What's the time box?
Output Format
## Intent Classification
**Type**: [Refactoring | Build | Mid-sized | Collaborative | Architecture | Research]
**Confidence**: [High | Medium | Low]
**Rationale**: [Why this classification]
## Pre-Analysis Findings
[Results from explore/librarian if launched]
## Questions for User
1. [Most critical question first]
2. [Second priority]
## Identified Risks
- [Risk]: [Mitigation]
## Directives for Prometheus
### Core Directives
- MUST: [Required action]
- MUST NOT: [Forbidden action]
### QA/Acceptance Criteria Directives
- MUST: Write acceptance criteria as executable commands
- MUST NOT: Create criteria requiring "user manually tests..."
## Recommended Approach
[1-2 sentence summary]
Critical Rules
NEVER:
- Skip intent classification
- Ask generic questions ("What's the scope?")
- Suggest acceptance criteria requiring user intervention
ALWAYS:
- Classify intent FIRST
- Be specific in questions
- Explore before asking (for Build/Research)
- Include QA automation directives
When not to use it
- →When implementing or modifying files
- →When the intent classification step is skipped
- →When asking generic questions
Limitations
- →Operates in a read-only capacity
- →Must classify intent as the first step
- →Does not implement or modify files
How it compares
This skill provides a structured pre-planning analysis to prevent AI failures, contrasting with direct planning without initial intent classification.
Compared to similar skills
metis side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| metis (this skill) | 0 | 2mo | No flags | Advanced |
| create-plan | 36 | 8mo | Review | Beginner |
| project-planner | 32 | 9mo | Review | Intermediate |
| system-design | 19 | 9mo | No flags | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by Lee-SiHyeon
View all by Lee-SiHyeon →You might also like
create-plan
antinomyhq
Generate detailed implementation plans for complex tasks. Creates comprehensive strategic plans in Markdown format with objectives, step-by-step implementation tasks using checkbox format, verification criteria, risk assessments, and alternative approaches. Use when users need thorough analysis and structured planning before implementation, when breaking down complex features into actionable steps, or when they explicitly ask for a plan, roadmap, or strategy. Strictly planning-focused with no code modifications.
project-planner
adrianpuiu
Comprehensive project planning and documentation generator for software projects. Creates structured requirements documents, system design documents, and task breakdown plans with implementation tracking. Use when starting a new project, defining specifications, creating technical designs, or breaking down complex systems into implementable tasks. Supports user story format, acceptance criteria, component design, API specifications, and hierarchical task decomposition with requirement traceability.
system-design
lagz0ne
Use when designing, architecting, or planning a new system from requirements or ideas - transforms concepts into navigable design catalog using EventStorming methodology, Mermaid diagrams, and progressive elaboration through 5 phases (Requirements, Big Picture, Processes, Data/Flows, Integration)
spec-kit-workflow
jmanhype
Guides specification-driven development workflow. Automatically invoked when discussing new features, specifications, technical planning, or implementation tasks. Ensures proper workflow phases (specify → clarify → plan → checklist → tasks → analyze → implement).
sparc-methodology
ruvnet
SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) comprehensive development methodology with multi-agent orchestration
spec-workflow
TencentCloudBase
Standard software engineering workflow for requirement analysis, technical design, and task planning. Use this skill when developing new features, complex architecture designs, multi-module integrations, or projects involving database/UI design.