By affixpin
Socratic Development - Question before acting. A methodology that uses discovery, architect, and simplifier agents to build the right thing.
Use this agent when you need to plan features, brainstorm solutions, design system architecture, or research elegant approaches to problems before implementation. This agent is ideal for creating technical specifications, defining logic flows, and documenting solution designs. Examples: <example> Context: User wants to plan a new authentication system before coding it. user: "I need to add OAuth2 authentication to our API" assistant: "This requires careful architectural planning. Let me use the architect agent to design the authentication flow and document the approach." <commentary> Since the user needs to plan a feature before implementation, use the architect agent to research best practices and create a comprehensive plan in markdown. </commentary> </example> <example> Context: User is facing a complex problem and needs to think through solutions. user: "Our database queries are getting slow, we need to figure out how to optimize them" assistant: "Let me use the architect agent to analyze potential optimization strategies and document a plan." <commentary> The user has a problem that requires research and planning before implementation. Use the architect agent to brainstorm solutions and create a documented approach. </commentary> </example> <example> Context: User wants to design a new feature's logic before writing actual code. user: "We need to implement a rate limiting system, can you help me think through how it should work?" assistant: "I'll use the architect agent to design the rate limiting architecture and document the logic flow." <commentary> This is a design and planning task. The architect agent will create pseudocode and architectural documentation in markdown files. </commentary> </example>
Use this agent to gather requirements through questioning before any planning begins. The discovery agent asks probing questions in batches (2-3 at a time) until the user signals they're done. Outputs a structured requirements document that feeds into architect. <example> Context: User wants to build a feature but hasn't fully specified requirements. user: "I want to add user notifications" assistant: "Let me use the discovery agent to gather requirements first." <commentary> Before planning, use discovery to understand the problem space through questioning. </commentary> </example>
Use this agent to review and simplify architectural plans. The simplifier tests the plan against user flows from the requirements, identifies unnecessary complexity, and asks the user before removing anything. Outputs a streamlined plan. <example> Context: Architect created a plan that might be over-engineered. user: "Simplify the auth-plan.md" assistant: "I'll use the simplifier to review the plan against requirements and remove unnecessary complexity." <commentary> Use simplifier after architect to strip away over-engineering. </commentary> </example>
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
A Claude Code plugin that implements the Socratic method for software development.
Don't assume. Question. Then act.
/plugin marketplace add affixpin/socratic
/plugin install socratic@affixpin-socratic
/plugin update socratic
Note: This plugin is in beta. Run the update command frequently to get the latest fixes and features.
Socrates believed that wisdom begins with questioning. He never claimed to have answers - instead, he asked probing questions until the truth emerged.
This plugin applies the same principle to coding. Every agent questions before acting. No assumptions survive unexamined.
┌─────────────┐
│ Request │
└──────┬──────┘
│
▼
┌─────────────┐
│ Discovery │ "What problem? For whom? Why now?"
└──────┬──────┘
│
▼
┌─────────────┐
│ Architect │ "What approach? What tradeoffs?"
└──────┬──────┘
│
▼
┌─────────────┐
│ Simplifier │ "Is this needed? What can we remove?"
└──────┬──────┘
│
▼
┌─────────────┐
│ Implement │
└─────────────┘
| Agent | Purpose | Output |
|---|---|---|
discovery | Gather requirements through questioning | *.discovery.md |
architect | Design solutions with tradeoff analysis | *.architect.md |
simplifier | Remove unnecessary complexity | *.simplifier.md |
/socratic:socratic - Start the full Socratic workflow/socratic:socratic
> What are we building?
"I want to add user authentication"
"Use the discovery agent to gather requirements for the auth feature"
"Use the architect agent to plan the auth system"
"Use the simplifier to review auth-system.architect.md"
"[q] Fix the typo in the README"
Agents write to .claude/socratic/ in your project:
your-project/.claude/socratic/
├── auth.discovery.md
├── auth.architect.md
└── auth.simplifier.md
"I know that I know nothing." - Socrates
The best code comes from admitting you don't fully understand the problem yet. These agents question relentlessly until clarity emerges.
No rushing to solutions. No assuming requirements. No unexamined complexity.
MIT
npx claudepluginhub affixpin/socratic --plugin socraticYou work with me (Claude) - I guide your workflow and suggest next actions.
A lightweight plugin for clarifying tasks and requirements through structured questions
Meta-cognition: refine input through brainstorming, refine output through challenge and condensed communication mode.
Spec-driven development workflow system with structured phases: Requirements → Design → Tasks → Implementation
No description provided.
Intelligent draw.io diagramming plugin with AI-powered diagram generation, multi-platform embedding (GitHub, Confluence, Azure DevOps, Notion, Teams, Harness), conditional formatting, live data binding, and MCP server integration for programmatic diagram creation and management.