Start a New Project

Receiving a client brief and turning it into a working skeleton in the same day is the mark of a high-velocity team. With Sun Agent Kit, you feed the brief directly into the toolchain — architecture decisions, folder structure, CI setup, and a development plan all come out the other side before you write a single line of business logic.

Overview

Goal: Go from a client brief to a running, planned project skeleton ready for feature development
Time: 30–60 minutes (vs 4–8 hours manual)
Agents used: planner, reviewer
Commands: /sk:bootstrap, /sk:plan, /sk:scout, /sk:docs

Prerequisites

• Sun Agent Kit installed (installation guide)
• Node.js 18+ or Bun runtime available
• A project brief — plain text, PDF, or a URL to a spec doc is fine
• Git initialized in your target directory (git init)
• Access credentials for any third-party services named in the brief (can be added later)

Step-by-Step Workflow

Step 1: Bootstrap the Project Skeleton

/sk:bootstrap "Node.js REST API for an e-commerce platform — PostgreSQL, Express, JWT auth, product catalog, cart, orders"

What happens: The agent:

1. Analyzes your project description to detect tech stack, database, and domain areas
2. Generates folder structure with routes, controllers, services, and models
3. Installs framework and development dependencies
4. Creates configuration files (.env.example, tsconfig.json, Dockerfile)
5. Runs initial typecheck to verify the skeleton compiles clean

Step 2: Generate the Implementation Plan

/sk:plan "Three sprints: Sprint 1 auth + catalog, Sprint 2 cart + orders, Sprint 3 payments + admin panel"

What happens: The agent:

1. Reads the generated codebase structure and builds a dependency graph
2. Writes phase files for each sprint under the plans/ directory
3. Breaks each phase into tasks and resolves dependencies between them
4. Identifies the critical path and saves an overview to plans/plan.md

Step 3: Review the Architecture

/sk:scout "review the generated structure and flag any architectural concerns before development starts"

What happens: The agent:

1. Scans the generated scaffold and reads project files
2. Checks for missing middleware, empty directories, and structural gaps
3. Flags warnings (e.g., missing rate limiting, empty migrations directory)
4. Saves an architecture report to plans/reports/scout-report.md

Step 4: Generate Initial Documentation

/sk:docs "generate README, API overview, and local dev setup guide"

What happens: The agent:

1. Reads configuration files to understand the project setup
2. Discovers route stubs and documents expected request/response shapes
3. Writes README, API overview, and local dev setup guide
4. Verifies that internal cross-references in the docs resolve correctly

Step 5: Commit the Baseline

/sk:git cm

What happens: The agent:

1. Stages all project files, respecting .gitignore (.env excluded automatically)
2. Writes a conventional commit message describing the scaffold
3. Creates the initial commit as the baseline for Sprint 1

Complete Example: Client Sends Brief for an E-Commerce App

Scenario: A client emails a 2-page brief on a Tuesday afternoon. They need an MVP backend for an online apparel store: user registration, product browsing, cart, checkout with Stripe, and an admin panel to manage inventory. Delivery is 6 weeks.

Monday morning you run:

# 1. Bootstrap from the brief text (paste or pipe it in)
/sk:bootstrap "E-commerce backend: user auth (email + Google OAuth), product catalog with categories and variants, shopping cart with session persistence, Stripe checkout, order history, admin CRUD for products and orders. Stack: Node.js, Express, PostgreSQL, Redis for sessions."

# 2. Plan across the 6-week delivery timeline
/sk:plan "6 weeks, 2-week sprints. Sprint 1: auth + catalog. Sprint 2: cart + checkout. Sprint 3: orders + admin."

# 3. Scout for problems before the team picks up tickets
/sk:scout "review generated scaffold for security gaps, missing middleware, and any structural issues"

# 4. Write docs the client can review
/sk:docs "README with setup instructions, API contract stubs, deployment notes for the client's AWS environment"

# 5. Commit and push
/sk:git cm

Result: By mid-morning, the team has a compiling project skeleton, a multi-phase plan with tasks organized across phases, a scout report flagging warnings, and clean documentation the client can read. Feature development starts immediately.

Time Comparison

Best Practices

1. Put domain language in the bootstrap prompt ✅

The more specific your description — data models, third-party services, team constraints — the more accurate the scaffold. “Node.js API with Stripe and PostgreSQL” produces a better result than “web backend”.

2. Run scout before committing to the plan ✅

The scout agent reads the generated skeleton and catches structural issues before they become technical debt. Run it between bootstrap and plan, not after.

3. Don’t skip /sk:plan even for small projects ✅

Even a 2-week project benefits from a written plan. It doubles as onboarding material for new teammates and a scope reference for the client.

4. Feeding a vague one-liner to /sk:bootstrap ❌

/sk:bootstrap "build a website" generates a generic skeleton that will need substantial rework. Spend 10 minutes extracting specifics from the client brief first.

5. Committing .env files ❌

Sun Agent Kit’s commit command respects .gitignore automatically, but double-check before push. Never commit real credentials, even to a private repo.

Troubleshooting

Problem: Bootstrap hangs at dependency install

Solution: Check your network and npm/bun registry access. If install continues to fail, scaffold the project first and then run npm install manually after bootstrap completes.

Problem: Plan phase files are too granular (100+ tasks per phase)

Solution: Your sprint description is too open-ended. Narrow each sprint to 2–3 major features: /sk:plan "Sprint 1: user registration and JWT auth only".

Problem: Scout report is empty

Solution: The scout agent needs at least some source files to analyze. Run after /sk:bootstrap completes, not before.

Problem: TypeScript errors in the generated skeleton

Solution: Run /sk:fix "fix all TypeScript errors in the generated scaffold" — the debugger agent resolves import and type errors in generated files.

Next Steps

• Onboard to Existing Codebase — use when you’re taking over from another team instead of starting fresh
• Add a New Feature — the next step after your scaffold is in place
• Build a REST API — go deeper on API design and endpoint implementation

Key takeaway: A client brief should never sit in your inbox for more than an hour — /sk:bootstrap turns it into a compiling project skeleton with a written plan while you drink your coffee.