strategic-partner
A strategic advisory skill for Claude Code (an installable add-on that extends Claude Code's behavior) that separates thinking from building. It thinks with you in one session, asking the right questions, challenging assumptions, and framing problems before jumping to solutions. Then it packages the implementation work for fresh sessions where the full context window is available. Decisions persist. Context stays clean.
What's new — 8.0.0 — Think together with fewer interruptions. Explore ideas
without being pushed to choose, get current project status, and carry approved
work through its corrections and checks. A handoff (a saved summary that lets a
fresh session pick up where you left off) keeps the useful context without a
closing questionnaire. The rules that stop Strategic Partner from editing your
source files are unchanged, and both ways of installing it now share one voice.
See CHANGELOG.md for prior releases.
The problem
AI coding assistants degrade as conversations grow. Every tool call, file read and exchange pushes the original instructions further from the model's attention. Strategic Partner (SP for short) separates the two jobs: one long-running session where decisions accumulate, and disposable sessions where the building happens with clean context.
Who is this for
Solo developers — A second brain that interrogates your assumptions before the first line is written, picks the right tool, and remembers decisions across sessions so they never get re-litigated.
Team leads — Consistent prompt quality across implementation sessions, with a decision log that survives context resets. Your architectural intent carries forward even when the building happens in fresh windows.
Non-technical PMs — Describe what you need in plain language. SP handles the translation into technical prompts, breaks large features into phased delivery, and reports back in terms you can act on. Knowing which skill or model suits a task is never required.
How it works
Two sessions, one loop. SP runs the advisor in one session. Your installed implementation skills, or background agents, do the building in another. The session that builds is the executor.
+----------------------------------+ +----------------------------------+
| SESSION 1: ADVISOR (persistent) | | SESSION 2: EXECUTOR (disposable)|
| | | |
| Strategic Partner | | /feature-dev — an external |
| | | skill, used here as an example |
| - Thinks with you | | (or whatever skill SP picks) |
| - Challenges your assumptions | | |
| - Crafts implementation prompts | | - Builds what SP specified |
| - Routes to the right skill | | - Keeps the settled decisions |
| - Tracks decisions and state | | - Judges the rest itself |
| - Stays open across phases | | - Commits when done |
| | | |
| KEEP THIS ONE OPEN. | | Opens fresh. THROWAWAY. |
+----------------+-----------------+ +----------------+-----------------+
| |
| 1. SP crafts prompt ----------------> |
| | 2. Paste and run
| |
| 4. SP reviews, plans next <--------- | 3. Report back
+----------------------------------------+
SP never builds, and the executor never re-opens a settled decision. Product and architecture calls are made with you before the prompt is written, and the executor holds to them while still making the ordinary implementation judgments any build needs, inside the boundaries the prompt sets. SP reviews the actual diff of what landed, not just a summary, then crafts the next prompt.
What you get
One illustrative walk-through, not a fixed script.
You say: "We need to build an onboarding flow."
Without an advisor — the session starts building a wizard. Three files in, nobody has asked whether a wizard is the problem.
With one — SP names it as a solution wearing a problem's clothes and asks what is actually going wrong. The real answer turns out to be that 60% of signups quit before connecting a data source. SP reads your project rules file (CLAUDE.md, which Claude Code loads automatically), notes React and Tailwind with no modal library, and puts three approaches on the table (minimal, recommended, lateral) with a pick and a reason for it.
Only once a direction is chosen does SP write prompts: research first, then the interface, then the wiring. Each prompt carries the files to read first, the constraints from your rules file, a verification checklist, safety labels on the key recommendations, the expected commit message, and what is explicitly out of scope. Approved work then carries through its own corrections and checks with the same executor, so a small fix costs no fresh round of approvals.
Quick start
Command names: the plugin install prefixes every command with
/strategic-partner-plugin:; the standalone install uses
/strategic-partner:. Examples below use the plugin form.
Install as a plugin (recommended — Claude Code manages the install)
/plugin marketplace add JimmySadek/strategic-partner
/plugin install strategic-partner-plugin@strategic-partner
/reload-plugins
To update, run both commands below, then restart Claude Code. The first refreshes the listing; the second moves the install.
/plugin marketplace update strategic-partner
/plugin update strategic-partner-plugin@strategic-partner
Plugin installs need no setup step. Claude Code reads the commands, the event scripts (the small scripts it runs when a session starts or a reply ends) and the voice style (the formatting profile that keeps replies scannable for non-technical readers) straight out of the plugin.
Install as a standalone skill
Status: maintained, but no longer receiving new features. The plugin
above is the main path. To move an existing standalone install over in one
step, run /strategic-partner:try-plugin.
git clone https://github.com/JimmySadek/strategic-partner.git <your-skills-dir>/strategic-partner
cd <your-skills-dir>/strategic-partner
./setup
Clone rather than using the skills command-line installer: for this repository's layout that installer fetches the main instruction file only, without the commands, event scripts, references, setup script and voice style. setup registers the subcommands and installs the voice style. It keeps an existing style, and warns rather than overwriting when the installed copy is out of date. Restart Claude Code afterwards. Update and repair steps live in ARCHITECTURE.md.
Run
/strategic-partner-plugin:strategic-partner
Resume earlier work by naming a saved handoff file:
/strategic-partner-plugin:strategic-partner .handoffs/onboarding-flow-0304-1430.md
On the standalone install, /strategic-partner, /advisor and /sp all invoke the same skill. The plugin format provides no alias mechanism, so the plugin has none. Natural-language activation works on both.
What's included
- Thinking before building — SP frames the problem, challenges the premise, puts real alternatives on the table, and writes the implementation prompt only once a direction is settled.
- Room to explore — brainstorm openly, keep the useful possibilities visible, and settle on a direction when you are ready. The meaningful choices stay yours.
- Questions anyone can answer — clear options with a suggested path, so taking part needs no technical vocabulary.
- A boundary that holds — SP advises and never edits your implementation source, on every path that opens it, including a session you resume later. One gap stays open on purpose: a session resumed as a fork starts unprotected until SP is opened again.
- Memory that survives a fresh session — decisions, findings and parked work carry across sessions, and a saved handoff lets a new session recover the goal, the evidence and what it is still allowed to do.
Mechanism detail lives in ARCHITECTURE.md under "Capabilities in detail".
Subcommands
| Command | What it does |
|---|
/strategic-partner-plugin:help | List all subcommands and how to use them |
/strategic-partner-plugin:copy-prompt | Copy a recently emitted prompt (the block between the copy markers) to the OS clipboard |
/strategic-partner-plugin:handoff | Save the current work and a usable continuation prompt |
/strategic-partner-plugin:status | Where we stand, what's done, what's next |
/strategic-partner-plugin:update | Report your version and whether a newer release exists, then point to where updating happens (the standalone command also updates in place) |
/strategic-partner-plugin:serena | Check, install, repair, verify, or roll back Serena (SP's optional memory and code-search add-on) with a preview first |
/strategic-partner-plugin:codex-feedback | Cross-model adversarial review via Codex CLI |
/strategic-partner-plugin:context-file-scan | Read-only drift scan of your project rules files (CLAUDE.md, AGENTS.md, GEMINI.md) and .claude/rules |
/strategic-partner-plugin:report-issue — standalone form /strategic-partner:report-issue | Report an SP bug from any project: scrubbed draft, mandatory preview, filed only after you approve |
/strategic-partner-plugin:backlog | Triage parked work, grouped by how far along each item is, with an action menu. Flags backlog work that already shipped and asks before closing it |
/strategic-partner-plugin:switch-to-skill | Plugin only. Switch this install back to the standalone skill |
/strategic-partner:try-plugin | Standalone only. Switch this install from the skill to the plugin (same voice; Claude Code manages the plugin's files) |
Requirements
- Claude Code — SP runs inside Claude Code sessions
perl and shasum — called directly by the small scripts Claude Code runs on session events. Both ship with macOS. On Linux they come with your distribution's perl package; where shasum is packaged separately it is usually perl-Digest-SHA, and some distributions ship the equivalent sha256sum in coreutils instead.jq (a small command-line JSON processor) — install via brew install jq (macOS) or apt install jq / dnf install jq (Linux). Without it, the rules-file scanner won't run, the short session-opening summary is reduced, and rules-file writes plus handing a task to a background agent refuse rather than guess. Ordinary chat and prompt delivery are not blocked.- Python 3 (optional) — needed only by
./setup --audit-permissions, which checks for permission gaps that cause friction in advisory sessions
- Serena (recommended) — an add-on server (an MCP server: the standard way Claude Code plugs into outside tools) that gives SP cross-session memory and semantic code search. SP works fine without it; what goes missing is Serena's own decision log and that search. SP's other stores (your project rules file, Claude Code's own saved notes, and handoff files) carry on unchanged. SP-managed Serena binds to the exact repository or checkout you are in, starts without opening a browser tab, preserves existing memories, and never changes the setup without approval.
- Context7 (optional, also an add-on server) — library documentation lookup
- Codex CLI (optional) — cross-model adversarial review
Supported platforms
| Platform | Status |
|---|
| macOS 13.0+ / Linux (GNU coreutils) | ✅ Fully supported |
| Windows WSL2 (recommended) / WSL1 | ✅ Supported — inherits Linux support (WSL1: Claude Code sandboxing unavailable per Anthropic) |
| Windows native (Git Bash / MSYS2 / Cygwin) | ⚠️ Experimental — limits on symlinks, interpreters and install paths; needs the opt-in setting SP_ALLOW_NATIVE_WINDOWS=1. Use WSL2 |
| Windows native (cmd / PowerShell) | ❌ Unsupported — Claude Code requires a Bash-compatible shell |
Troubleshooting
| Scenario | What happens | What to do |
|---|
| Serena missing, unreliable, or noisy | Cross-session memory and semantic navigation are reduced; a browser tab may open on start, or two Serena servers may run at once | Run /strategic-partner-plugin:serena. SP diagnoses locally, previews the smallest safe fix, and keeps working with repository-native search if the fix is declined. |
| The executor hits a permission wall | A needed operation falls outside what the task was allowed to do | Check which operation was refused and what the task was authorized for. The same executor continues where that is supported; a new build request that changes source still needs your explicit consent. |
| An implementation session fails | The executor reports errors or incomplete work | SP diagnoses the cause, continues the corrections already authorized, and verifies the result. |
| Codex CLI not found | Cross-model review is unavailable | Install from github.com/openai/codex and run codex login. The feature is optional. |
License
MIT
