Why Commands?

Claude Code, GitHub Copilot, and OpenCode read your codebase, edit files, run commands, and spawn sub-agents on their own. Hyprlayer’s commands and agents sit on top of that.

What the Base Tools Already Do

• Claude Code ships built-in sub-agents (Explore, Plan, general-purpose), auto-memory across sessions (MEMORY.md), and runs git commands, creates commits, and opens PRs.
• GitHub Copilot ships agent, plan, and ask modes, session memory, and cloud agents that create PRs.
• OpenCode gives you multi-provider model access with similar agentic capabilities.

All three read your code, make multi-file edits, run tests, and iterate on failures. Ask one of them to rename a variable and it will. Skip the commands.

Non-trivial work exposes the gaps.

What Commands Add

Enforced Phase Separation

Ask any of these tools to “build feature X” and they start writing code. They read a few files first, then research, planning, and implementation blur into a single pass. You never see a plan before the code lands.

• /research_codebase documents and nothing else. It describes what exists, where it lives, and how it works. It will not suggest improvements, critique the code, or propose changes unless you ask for that. Left to themselves, Claude Code and Copilot editorialize.
• /create_plan produces a plan: phased steps, specific file changes, success criteria, checkboxes. It writes no code. Hyprlayer instructs the agent to be skeptical, so it challenges your assumptions and names the risks instead of agreeing with you.
• /implement_plan takes a plan file path and follows the spec. It reads the plan, reads every referenced file, implements phase by phase, verifies success criteria after each phase, and checks off completed sections in the plan file. It tells you when it deviates.

Base tools let you ask for a plan first. Nothing stops the model from jumping ahead, and you get no artifact to carry into the next phase.

A Persistent, Shared Knowledge Base

Claude Code reads CLAUDE.md for project instructions and keeps auto-memory for facts like “this project uses pnpm.” GitHub Copilot keeps session memory that clears when the conversation ends, plus repository-level custom instructions. Neither gives your team a structured, shared knowledge system.

The thoughts directory is a git-backed repository of research, plans, PR descriptions, and handoff documents, organized by project and searchable by AI agents.

• /research_codebase writes findings to thoughts/shared/ or thoughts/<username>/. Next session, the research is still there, and a teammate’s session reads it too.
• /create_plan saves plans to thoughts/shared/plans/YYYY-MM-DD-description.md. Your team reviews them asynchronously, refines them with /iterate_plan, and cites them months later.
• /describe_pr reads a PR template from thoughts/shared/pr_description.md and saves the generated description to thoughts/shared/prs/. Every PR lands with the same structure.
• /create_handoff compacts the current session’s context into a document at thoughts/shared/handoffs/. A new session picks it up with /resume_handoff and continues where you left off.

Post-commit hooks sync the repository after each code commit, and the searchable index (thoughts/searchable/) gives agents flat access to everything.

CLAUDE.md and session memory are per-developer and unstructured. The thoughts directory is versioned, git-native, and shared across your team, and commands read and write it on their own.

Specialized Sub-Agents with Focused Roles

Claude Code’s built-in sub-agents are generic. Explore is a fast, read-only codebase searcher. Plan does read-only research. Useful, but neither knows your domain.

Hyprlayer installs eight specialized agents with narrow purposes:

• codebase-locator finds files and components relevant to a task. Describe what you want in English and it locates the code, rather than matching strings.
• codebase-analyzer works out how a specific piece of code behaves, down to the implementation.
• codebase-pattern-finder surfaces similar implementations already in your codebase. It returns concrete code from the API endpoints you have, so the one you add matches them.
• thoughts-locator and thoughts-analyzer search the thoughts directory and surface prior research, existing plans, and history the base tools don’t know exists.
• web-search-researcher searches the web for API documentation and library usage patterns that live outside your codebase.
• jira-ticket-reader and jira-searcher pull ticket details from JIRA and find related issues.

/research_codebase spawns codebase-locator, codebase-analyzer, and codebase-pattern-finder in parallel, each on a different aspect of the codebase, then synthesizes one document from what they return.

Base-tool agents know nothing about your thoughts directory, your JIRA instance, or the patterns in your code.

Per-Command Model Selection

You run whatever model your session started with. Claude Code uses the model in your settings; Copilot uses the one you picked from the dropdown. Switching means stopping to switch.

Each command pins its own model:

• Opus for /research_codebase, /create_plan, and /iterate_plan, where thorough reasoning is worth the cost and the wait.
• Sonnet for /implement_plan, /validate_plan, /commit, /describe_pr, and the rest, where you want the iteration cycle to close fast.

Opus and Sonnet have different strengths. Opus produces more thorough analysis during research and planning, and Sonnet turns implementation cycles around faster. The command picks for you.

Behavioral Constraints You’d Forget to Specify

Models agree with your approach, add “Co-Authored-By” lines to commits, suggest improvements when you asked for documentation, and implement things their own way when a plan exists.

Commands encode the corrections:

• /research_codebase documents what exists and withholds the improvement suggestions the model wants to volunteer.
• /create_plan challenges your assumptions and names the risks. Models default to agreement; this command overrides that.
• /commit adds no AI attribution: no “Co-Authored-By,” no “Generated with,” no “AI-assisted.” Imperative mood, focused on why rather than what, specific file paths instead of git add -A or git add ., and your approval before anything lands.
• /implement_plan reads every file the plan references, verifies success criteria after each phase, updates the checkboxes, and reports deviations rather than papering over them.
• /validate_plan checks every success criterion, reports pass or fail on each, and flags deviations, missing implementations, and regressions, drawing evidence from diffs, test results, and codebase state.
• /describe_pr reads your team’s PR template, fills out every section, runs the verification commands the template specifies, and updates the PR with gh pr edit.
• /founder_mode cherry-picks the commit to a new branch, creates a JIRA ticket, and opens a PR, dragging finished work back into the team’s process.

You could type all of this at the start of a conversation. Six exchanges later the model has drifted and you’ve stopped repeating yourself. Commands hold the constraints for the whole session.

Session Continuity Across Context Limits

A long session fills its context window. Start a new one and you lose the last one. Claude Code’s auto-memory keeps some preferences and none of your working state, and Copilot’s session memory is gone.

• /create_handoff compacts your session into a structured document: what you finished, what’s left, the decisions you made, the files you touched, the blockers you hit. It lands in thoughts/shared/handoffs/.
• /resume_handoff reads that document, restores context by reading every file it references, and picks up where the previous session stopped.

The model remembers nothing here. One session writes a document describing its working state, the next session reads it, and neither Claude Code nor Copilot ships anything equivalent.

Git Workflow Opinions

All three tools run git commands without an opinion about how to use git. They commit everything with git add ., write generic messages, and open PRs against no template.

• /commit reviews the changes, groups related files into atomic commits, drafts messages in imperative mood focused on why, and shows you the plan before running anything. It passes specific paths to git add, never -A or ., and never adds AI attribution.
• /describe_pr reads your team’s PR template from the thoughts directory, analyzes the full diff and commit history, runs whatever verification the template calls for (make check test, say), fills every section, saves the result to thoughts, and updates the PR on GitHub.
• /local_review sets up a git worktree for a colleague’s branch. It resolves the PR number to a branch name, extracts ticket info, creates the worktree, installs dependencies, and launches an AI session in the isolated checkout.

Cross-Session, Cross-Tool Portability

Claude Code keeps custom commands in ~/.claude/commands/. Copilot keeps its own somewhere else. Switch tools and you start over.

hyprlayer ai configure installs the same commands and agents for Claude Code, GitHub Copilot, or OpenCode, and the thoughts directory doesn’t care which one wrote to it. Plan a feature in Claude Code, implement it with Copilot. Write a handoff in one tool, resume it in another.

When to Skip Commands

Reach for the base tool when:

• You have a one-off question. “What does this function do?” doesn’t need /research_codebase.
• The change is small. Renaming a variable or fixing a typo doesn’t need a plan.
• You want to think out loud before committing to a structure.

Anything that spans more than one sitting is worth the structure.