Initialize a new project with deep context gathering and PROJECT.md
Initializes a new project with deep context gathering and creates PROJECT.md
/plugin marketplace add glittercowboy/get-shit-done/plugin install get-shit-done@get-shit-donegsd/Initialize a new project through comprehensive context gathering.
This is the most leveraged moment in any project. Deep questioning here means better plans, better execution, better outcomes.
Creates .planning/ with PROJECT.md and config.json.
<execution_context>
@/.claude/get-shit-done/references/principles.md
@/.claude/get-shit-done/references/questioning.md
@/.claude/get-shit-done/templates/project.md
@/.claude/get-shit-done/templates/config.json
</execution_context>
<process> <step name="setup">MANDATORY FIRST STEP — Execute these checks before ANY user interaction:
Abort if project exists:
[ -f .planning/PROJECT.md ] && echo "ERROR: Project already initialized. Use /gsd:progress" && exit 1
Initialize git repo in THIS directory (required even if inside a parent repo):
# Check if THIS directory is already a git repo root (handles .git file for worktrees too)
if [ -d .git ] || [ -f .git ]; then
echo "Git repo exists in current directory"
else
git init
echo "Initialized new git repo"
fi
Detect existing code (brownfield detection):
# Check for existing code files
CODE_FILES=$(find . -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.swift" -o -name "*.java" 2>/dev/null | grep -v node_modules | grep -v .git | head -20)
HAS_PACKAGE=$([ -f package.json ] || [ -f requirements.txt ] || [ -f Cargo.toml ] || [ -f go.mod ] || [ -f Package.swift ] && echo "yes")
HAS_CODEBASE_MAP=$([ -d .planning/codebase ] && echo "yes")
You MUST run all bash commands above using the Bash tool before proceeding.
If existing code detected and .planning/codebase/ doesn't exist:
Check the results from setup step:
CODE_FILES is non-empty OR HAS_PACKAGE is "yes"HAS_CODEBASE_MAP is NOT "yes"Use AskUserQuestion:
If "Map codebase first":
Run `/gsd:map-codebase` first, then return to `/gsd:new-project`
Exit command.
If "Skip mapping": Continue to question step.
If no existing code detected OR codebase already mapped: Continue to question step.
</step> <step name="question">1. Open (FREEFORM — do NOT use AskUserQuestion):
Ask inline: "What do you want to build?"
Wait for their freeform response. This gives you the context needed to ask intelligent follow-up questions.
2. Follow the thread (NOW use AskUserQuestion):
Based on their response, use AskUserQuestion with options that probe what they mentioned:
3. Sharpen the core:
Use AskUserQuestion:
4. Find boundaries:
Use AskUserQuestion:
5. Ground in reality:
Use AskUserQuestion:
6. Decision gate:
Use AskUserQuestion:
If "Ask more questions" → check coverage gaps from questioning.md → return to step 2.
If "Let me add context" → receive input via their response → return to step 2.
Loop until "Create PROJECT.md" selected.
Synthesize all context into .planning/PROJECT.md using the template from templates/project.md.
For greenfield projects:
Initialize requirements as hypotheses:
## Requirements
### Validated
(None yet — ship to validate)
### Active
- [ ] [Requirement 1]
- [ ] [Requirement 2]
- [ ] [Requirement 3]
### Out of Scope
- [Exclusion 1] — [why]
- [Exclusion 2] — [why]
All Active requirements are hypotheses until shipped and validated.
For brownfield projects (codebase map exists):
Infer Validated requirements from existing code:
.planning/codebase/ARCHITECTURE.md and STACK.md## Requirements
### Validated
- ✓ [Existing capability 1] — existing
- ✓ [Existing capability 2] — existing
- ✓ [Existing capability 3] — existing
### Active
- [ ] [New requirement 1]
- [ ] [New requirement 2]
### Out of Scope
- [Exclusion 1] — [why]
Key Decisions:
Initialize with any decisions made during questioning:
## Key Decisions
| Decision | Rationale | Outcome |
|----------|-----------|---------|
| [Choice from questioning] | [Why] | — Pending |
Last updated footer:
---
*Last updated: [date] after initialization*
Do not compress. Capture everything gathered.
</step> <step name="mode">Ask workflow mode preference:
Use AskUserQuestion:
Ask planning depth preference:
Use AskUserQuestion:
Depth controls compression tolerance, not artificial inflation. All depths use 2-3 tasks per plan. Comprehensive means "don't compress complex work"—it doesn't mean "pad simple work to hit a number."
Create .planning/config.json with chosen mode and depth using templates/config.json structure.
git add .planning/PROJECT.md .planning/config.json
git commit -m "$(cat <<'EOF'
docs: initialize [project-name]
[One-liner from PROJECT.md]
Creates PROJECT.md with requirements and constraints.
EOF
)"
</step>
<step name="done">
Present completion with next steps (see ~/.claude/get-shit-done/references/continuation-format.md):
Project initialized:
- Project: .planning/PROJECT.md
- Config: .planning/config.json (mode: [chosen mode])
[If .planning/codebase/ exists:] - Codebase: .planning/codebase/ (7 documents)
---
## ▶ Next Up
**[Project Name]** — create roadmap
`/gsd:create-roadmap`
<sub>`/clear` first → fresh context window</sub>
---
</step>
</process>
<output>
.planning/PROJECT.md.planning/config.json<success_criteria>
</success_criteria>