Your AI agent can execute tasks. Can it think strategically?
AI agents are great at implementation. Give them a spec, they'll write the code. But strategic work — exploring tensions, weighing tradeoffs, making decisions that hold up three months later — they're terrible at it. They skip exploration, collapse nuance, and produce plans that sound smart but don't survive contact with reality.
Git for Strategy fixes this. 21 skills organized into a 5-phase pipeline that gives your agent the discipline to explore before deciding, decide before building, track where it is, and learn from what it ships.
Measured outcomes from 25 real releases: 40-50% shorter timelines. 77 hours saved through pre-flight verification alone.
git clone https://github.com/TresPies-source/GitForStrategy.git
# Add the path to your plugins configurationgit clone https://github.com/TresPies-source/GitForStrategy.git
cp -r GitForStrategy/skills/ ~/.your-editor/skills/Full setup guides for Claude Code · Cowork · Cursor · Windsurf · VS Code · Gemini CLI
bash scripts/init-strategy.sh "my-project"EXPLORE → DECIDE → EXECUTE → TRACK → LEARN
↑ │
└──────────────── seeds ────────────────────────┘
Explore: Scout tensions, research deeply, explore before committing. /scout
Decide: Write specs grounded in reality, plan from files not memory. /spec
Execute: Commission autonomous agents with structured prompts, run parallel tracks, verify before shipping. /commission
Track: Know where you are in the pipeline, spot stale work, maintain visibility. /status
Learn: Run retrospectives, extract seeds, compress context for next time. /retro
Seeds: 13 reusable thinking patterns extracted from 25 real releases. The standard library for strategic thinking. /seed
You: /scout
Agent: What tension are you exploring?
You: We need to decide between building a native app or a web app.
Agent: [Generates a structured scout with 3-5 routes, tradeoffs,
cross-route patterns, and open questions — saved to scouts/]
You: /spec
Agent: [Takes the scouted direction and writes a production-ready
specification — saved to specs/]
You: /commission
Agent: [Transforms the spec into implementation prompts ready for
autonomous execution — saved to commissions/]
You: /status
Agent: Pipeline: Explore ✅ → Decide ✅ → Execute ✅ → Learn ⏳
Commission shipped 2 days ago. Retrospective due.
You: /retro
Agent: [Runs a structured retrospective, extracts seeds for next time
— saved to retros/ and seeds/]
| Phase | Skills | What You Get |
|---|---|---|
| Explore | 5 | Strategic scouting, iterative reframing, product positioning, deep/wide research, project exploration |
| Decide | 4 | Specification writing, context ingestion, frontend-from-backend grounding, file-based planning |
| Execute | 4 | Implementation prompts, parallel tracks, pre-flight checklists, agent handoffs |
| Track | 3 | Status writing, status templates, repo-level status and health |
| Learn | 4 | Retrospectives, seed extraction, memory garden, context compression |
| Patterns | 1 | 13 seed patches — the standard library for strategic thinking |
- 7 commands:
/scout,/spec,/commission,/retro,/seed,/status,/explore - 8 templates: Scout, spec, commission, retro, seed, status, handoff, checklist
- 4 scripts: Workspace initialization, pipeline validation, seed suggestion, context compression
- 13 seed patches: Reusable thinking patterns with triggers, steps, and evidence
- 6 platform guides: Claude Code, Cowork, Cursor, Windsurf, VS Code, Gemini CLI
- 3 hooks: Pre-scout validation, post-spec pipeline update, pre-commission quality gate
Seeds are reusable thinking patterns. Each has a trigger, steps, and evidence from real use.
| Seed | When To Use It |
|---|---|
| Three-Tiered Governance | Adding structure to a project or team |
| Pace of Understanding | Pressure to deliver before understanding |
| Cost Consciousness | Resource constraints feel limiting |
| Voice Before Structure | Creating artifacts for a project |
| Liberation Psychology | Barriers prevent contribution |
| Patient Learning | Learning something new under pressure |
| Era Architecture | Planning multiple releases |
| Semantic Clustering | Mapping what a system does |
| Context Iceberg | Organizing knowledge for retrieval |
| Spec-to-Prompt Pipeline | Moving from spec to implementation |
| Portability Tiers | Classifying by dependency depth |
| Agent Workspace | Coordinating across agents |
| Handoff Protocol | Passing work between agents |
Full seed documentation: seeds/
Planning-with-files is excellent. It gives your agent memory — three markdown files that persist context across sessions. We recommend it.
Git for Strategy is the next layer. Memory tells your agent what it's working on. Strategy tells it why, how to explore alternatives, when to commit, and what to learn from what it ships. They're complementary, not competitive.
| Planning-with-Files | Git for Strategy | |
|---|---|---|
| Problem solved | Agents forget context | Agents can't think strategically |
| Skills | ~3 | 21 |
| Commands | 2 | 7 |
| Templates | 3 | 8 |
| Seeds/Patterns | — | 13 |
| Measured outcomes | — | 40-50% timeline reduction |
Begin with a tension, not a solution. The quality of your strategic thinking is determined by the quality of your questions, not the speed of your answers.
Knowledge should compound, not evaporate. Every retrospective produces seeds. Every seed makes the next project better. The system improves with use.
Governance multiplies velocity. Structure isn't bureaucracy. Scout before deciding, spec before building, retro before starting over. The right constraints make you faster, not slower.
| Doc | What It Covers |
|---|---|
| Methodology | The full Git for Strategy methodology |
| Pipeline Reference | Detailed phase-by-phase reference |
| Measured Outcomes | Evidence from 25 real releases |
| Seeds Reference | Quick reference for all 13 patterns |
See CONTRIBUTING.md for how to contribute skills, seeds, and platform guides.
MIT
Built from 25 releases of real software. A Tres Pies Design project.