Documentation

Sun* Agent Kit Docs

Everything you need to get started and ship with AI agents.

Installation

4 steps to get started:

# 1. Authenticate with GitHub (Sun* account required)
gh auth login

# 2. Install the CLI
npm install -g sun-agent-kit-cli

# 3. Initialize in your project
cd my-project
sk init

# 4. Verify installation
sk doctor

Requirements: Node.js 18+ • GitHub CLI (gh) authenticated with your Sun* account

Quick Start

After sk init, start building in 3 steps:

# 1. Plan your feature
/sk:plan "Build a task management dashboard"

# 2. Implement it
/sk:cook

# 3. Ship it
/sk:code-review
/sk:ship

Use Cases

Real-world scenarios and the command flows to handle them:

Build a simple feature

Standard flow for well-defined tasks — plan, implement, review, ship.

/sk:plan "Add dark mode toggle"
/sk:cook
/sk:code-review
/sk:ship

Build a complex feature

Deep research and brainstorming before planning. For features with unknowns.

/sk:brainstorm "Real-time collaboration approach"
/sk:research "WebSocket vs SSE for collab"
/sk:plan:hard "Build real-time collaboration"
/sk:cook
/sk:code-review
/sk:ship

Fix a bug

Describe the bug and let the agent investigate, diagnose, and fix.

/sk:fix "Login fails with Google OAuth on mobile Safari"

Scout a codebase

Find files, understand structure, locate functionality before making changes.

/sk:scout "Find all payment processing files"

Brainstorm ideas

Explore approaches with trade-off analysis before committing to a direction.

/sk:brainstorm "Choose auth strategy: session vs JWT vs OAuth"

Migrate codebase to new flow

Analyse existing codebase, research target stack, choose the best approach, then plan and execute migration in parallel tracks.

# 1. Analyse current codebase — extract main features
/sk:scout "Map all features and modules in current codebase"

# 2. Research migration libraries and patterns
/sk:research "Best libraries for migrating this flow to Python"

# 3. Choose the best migration approach
/sk:brainstorm "Select optimal migration strategy — rewrite vs incremental"

# 4. Plan each feature track
/sk:plan "Migrate feature A to new flow"
/sk:plan:hard "Migrate feature B — complex dependencies"

# 5. Implement all plans
/sk:cook

# 6. Review and ship
/sk:code-review

Generate docs / proposal

Auto-generate or update project documentation, or create a technical proposal.

/sk:docs
# or
/sk:plan "Write RFC for new caching layer"

Upsale / improvement proposal

Scout codebase for edge cases, research industry standards, brainstorm improvements, then produce separate technical and business proposal documents.

# 1. Scout — analyse codebase, find edge cases
/sk:scout "Analyse codebase, map modules, identify edge cases and tech debt"

# 2. Research — industry standards for this problem
/sk:research "Industry best practices and benchmarks for this problem domain"

# 3. Brainstorm — technical & business improvement points
/sk:brainstorm "What technical and business improvements can increase value and growth?"

# 4. Plan — technical proposal
/sk:plan "Create technical improvement proposal with architecture recommendations"

# 5. Plan — business proposal
/sk:plan "Create business proposal with ROI analysis and prioritised roadmap"

# 6. Cook — generate proposal documentation
/sk:cook "Write comprehensive proposal document combining technical and business plans"

Code review

Adversarial review with edge-case detection on pending changes or a PR.

/sk:code-review

Core Commands

Command	Description
`/sk:plan`	Research, analyze, create implementation plan with phases
`/sk:cook`	Execute plan — orchestrates implementer, tester, reviewer
`/sk:code-review`	Adversarial code review with edge case detection
`/sk:ship`	Merge, test, commit, push, and create PR
`/sk:fix`	Debug bugs, test failures, CI/CD issues
`/sk:brainstorm`	Explore approaches before planning
`/sk:scout`	Find files related to a feature or concept
`/sk:docs`	Update project documentation

All commands use the /sk: prefix. Run sk skills list for the full catalog.

Workflow

The core development loop:

brainstorm → plan → cook → review → ship

Each step orchestrates specialized subagents. Plans output to plans/ directory with phases, reports, and research.

Pro Tips

/sk:plan:hard — deep research before planning (complex features)
/sk:cook --auto — auto-approve all steps (trusted tasks)
/sk:graphify ./src — build knowledge graph before large features

Agents

8 core agents coordinate the development lifecycle:

Agent	Description
`planner`	Architecture breakdown, phase planning
`implementer`	Code implementation per phase
`tester`	Unit + integration tests, coverage
`reviewer`	Code quality, spec compliance
`debugger`	Root-cause investigation
`researcher`	Technical research (parallel)
`doc-writer`	Documentation updates
`git-manager`	Git operations, commits

Agents spawn other agents — planner triggers researchers in parallel, then hands off to implementer.