Run Your SDLC in Co-Pilot Mode: A Developer's Getting-Started Guide

Install once

One package carries the skills, the learning hooks, and the loop. With the Hyperstruck SDK installed (it ships with your API key), the copilot connects like this:

python -m hyperstruck.ide.install

That copies the hyper-* skills into Claude Code and Cursor, deep-merges the learning hooks into each editor's config without touching any hooks you already have, and writes the Cursor recall nudge. It's idempotent, so re-running upgrades in place, and it only wires the editors you actually have. Restart your editor afterwards.

From here, recall and capture are automatic. hyper-reasoning is still there for open-ended planning when you want a structured plan on demand, and hyper-learning handles recall (it's also how recall reaches you on Cursor, where hooks can't inject context).

Configure access

The loop authenticates with a bearer token against https://api.hyperstruck.com. Grab an API key from your dashboard and hand it to the installer, which records it (and validates it) in ~/.hyperstruck/.env so the hooks can authenticate:

export HYPER_API_KEY="sk_live_..."        # never commit this
python -m hyperstruck.ide.install         # picks the key up and validates it

The install prints whether the key resolved. That's the one thing worth checking; everything else fails open, so a missing key or a network blip degrades to a silent no-op and never blocks your editing.

Choose your agents

One agent is enough to start: point the loop at it and every lesson lands in one place. The upgrade, once the loop has proved itself, is a small roster of agents scoped to the stages of your SDLC, each with its own instructions, model, and accumulated learnings. Learnings are stored per agent, so a focused roster keeps each one's experience clean and relevant, while a single agent keeps things simple. Both patterns work, and you're not locked into either, or into one repo: these are your agents, used across everything you do in the editor.

Create an agent with a single call. Match its reasoning_profile to how open-ended the stage is (fast for narrow answers, balanced for most work, full for deep design).

curl -s -X POST "$HYPER_BASE_URL/agents" \
  -H "Authorization: Bearer $HYPER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Technical Design Author",
    "description": "Produces implementation-ready technical designs for sizable changes.",
    "reasoning_profile": "full",
    "core_config": {
      "instructions": "You are a technical design author. Given a feature, produce current state and call sites, files to change, risks and trade-offs, edge cases, acceptance criteria, and a test plan. Cite evidence. Flag anything unverified.",
      "hitl_enabled": true
    }
  }'

You don't need to track the returned id. The skills list your agents and pick the one whose description fits the task at hand, so you reason and recall by intent, not by wiring IDs into prompts. That one agent is a complete setup on its own. When you're ready to grow into a roster, add an agent per stage with the same call. The fuller roster mirrors the loop:

Most people never need all seven. A single agent is the honest default; if you do split into a roster, start with Technical Design Author and Test + Security Reviewer, the two stages where a missed constraint costs you the most, and grow it as the loop proves itself.

The explicit skills pick the right agent for each task. The silent per-turn loop needs one default to learn into: if you have a single agent the installer wires it for you, and if you have several you point it at one with python -m hyperstruck.ide.install --agent-id <id>.

Watch it recall, automatically

Now the payoff, and you do nothing to trigger it. Because the hooks are wired, every prompt you send first pulls the lessons relevant to it and folds them in before the assistant acts. You write the same plain prompt you always would; the difference is what comes back.

Same feature, the exact same prompt. The cold run gives you what any agent gives you: delete the folder, delete the files, return success. With Hyperstruck installed, the hook has already pulled the lesson from a prior task ("unbounded bulk deletes lock large tables, estimate row count first and batch above a threshold") and folded it in before the model ran, so the implementation arrives with a preflight row count, bounded batches, a background job for large folders, and an audit log. Nobody typed those requirements, and nobody ran a recall command.

Here's the part that matters for a team, not just an individual. The engineer running this prompt isn't necessarily the one who learned the lesson. That batching rule could have come from a senior who spent a 2am shift untangling a production incident months ago. A junior implementing folder deletes today inherits it automatically, applied to their code before review, without ever having heard the war story. The institutional memory does the mentoring.

And because the learning is actually used in this implementation, it gets reinforced right here. Its standing climbs every time it proves useful on real work, so the lessons that keep paying off rise to the top on their own. You don't manage that.

For an open-ended stage, reach for hosted reasoning the same way. It assembles context from your session, runs the plan, and walks any review checkpoints:

Recall and capture rode the hooks automatically; reaching for /hyper-reasoning is the one explicit call you still make, for when you want a structured plan on demand.

Capture happens on its own

This is the step that makes tomorrow's run better than today's, and now you don't run it. As you work, each material turn is captured at its end and shipped for extraction, so the lessons land in the corpus with no command. The richest source is still code review: when you implement review fixes, the durable rules buried in those comments ("this query needs a tenant filter or it leaks across accounts") are captured the same way, so next time anyone touches a similar query the rule is already in the plan instead of scrolling off the thread.

What does not leave your machine is your code. The hook ships the shape of a turn, the tool, the path, the status, a clipped result, never raw file contents or diffs, and scrubs secrets before anything is sent. Learnings are about patterns, not literal source.

For durable manual curation, adding a high-signal rule verbatim, fixing one, pruning another, point at the curation API directly for now; a dashboard for exactly this is on the way. Keep manual learnings small and specific: "always add a date-range filter to analytics queries or responses exceed 30 seconds" beats "be careful with the API". From there, reinforcement does the curation for you, as a learning's standing climbs every time it proves useful on real work.