Copy This Template and Ship Faster

You’ve read about TRDs. Canvas alignment. Backlog management. ADRs. Now comes the hardest part:

Actually doing it.

The good news: you don’t need to build this from scratch. The template exists. The prompts are written. The structure is ready. You just need to copy it, customize it, and start using it.

Here’s how to get from zero to shipping in 5 steps.

Quick Start (5 Steps, 60 Minutes)

Step 1: Copy the Template (5 minutes)

Clone or copy the .assistant/ directory structure into your project:

your-project/
├── .assistant/
│   ├── assistant.yaml       # Configuration
│   ├── status.md            # Current project state
│   ├── plan.md              # Now/Next/Later timeline
│   ├── backlog.md           # Granular tasks
│   ├── task_log.md          # Session log
│   ├── history.md           # Project timeline
│   ├── canvas/              # Strategic context
│   │   ├── vision.md
│   │   ├── goals.md
│   │   ├── stakeholders.md
│   │   ├── questions.md
│   │   ├── ideas.md
│   │   └── notes.md
│   ├── adr/                 # Architecture decisions
│   │   ├── README.md
│   │   └── ADR-TEMPLATE.md
│   └── prompts/             # AI prompts for each phase
│       ├── project_startup.md
│       ├── kickoff.md
│       └── end_session.md
└── Makefile                 # Helper commands

What each file does:

assistant.yaml: Points to entry files for LLM rules
status.md: Single source of truth for current focus, risks, artifacts
plan.md: Now (this sprint), Next (upcoming), Later (backlog)
backlog.md: Granular tasks with acceptance criteria
task_log.md: Append-only log of every work session
canvas/: 6 files for strategic alignment (vision, goals, stakeholders, questions, ideas, notes)
adr/: Architecture Decision Records
prompts/: ChatGPT/Claude prompts for each workflow phase

Step 2: Generate Your TRD Using ChatGPT (20 minutes)

Use the TRD prompt from Post 2:

You are a technical requirements specialist. Generate a Technical Requirements Document (TRD) based on the following project:

Problem: [Describe what you're solving]
Target Users: [Who is this for?]
Key Features: [Bullet list of core functionality]
Constraints: [Technical, regulatory, or business constraints]

The TRD should include:
1. Executive summary (2-3 sentences)
2. Problem statement
3. Target users and personas
4. Core functional requirements (numbered list)
5. Non-functional requirements (performance, security, compliance)
6. Explicit non-goals (what we're NOT building)
7. Success criteria (measurable outcomes)
8. Technical constraints and dependencies
9. Risks and assumptions

Format as markdown. Be specific but concise. Use SMART criteria for success metrics.

Fill in your project details and paste into ChatGPT. Refine the output. Save it as .assistant/TRD.md.

Step 3: Fill the Canvas (30 minutes)

Open the canvas files and answer the strategic questions. Do this with your team if possible.

vision.md (10 minutes)

# Vision

## Purpose
[Where is this project going in 12 months?]

## Success Signals
[What will be true if this succeeds? Be specific.]

## Non-Goals
[What are we explicitly NOT doing?]

Example:

## Purpose
Build a privacy-first analytics dashboard for indie SaaS developers who want GDPR-compliant tracking without vendor lock-in.

## Success Signals
- 500 active developers using our SDK
- 10k tracked events per day
- Featured in Hacker News "Ask HN: Analytics alternatives to GA4"
- NPS >50 from beta users

## Non-Goals
- No enterprise features (SSO, compliance certifications)
- No visual funnel builder (code-first product)
- Not competing with Google Analytics on features

goals.md (10 minutes)

# Goals

## Short-term (4 weeks)
[What ships this month? Be measurable.]

## Mid-term (12 weeks)
[What ships this quarter?]

## Long-term (6 months)
[What's the 6-month milestone?]

Example:

## Short-term (4 weeks)
- Ship JavaScript SDK (npm package) with event tracking + page views
- Deploy backend API to production (99.9% uptime)
- Publish API docs + 2 quickstart tutorials

## Mid-term (12 weeks)
- Reach 50 active developers
- Add React/Vue framework integrations
- Launch privacy-focused marketing site

## Long-term (6 months)
- Reach 500 active developers
- Generate $2k MRR from premium tier (custom domains + extended retention)
- Open source core SDK

stakeholders.md (5 minutes)

# Stakeholders

[Who uses this? Who pays? Who builds? What do they expect?]

Example:

## Primary Users
- Indie SaaS developers (solo or 2-3 person teams)
- Technical founders without analytics expertise
- Developers migrating from Google Analytics or Plausible

Expectations: Fast setup (<10 mins), GDPR-compliant by default, transparent pricing

## Decision Makers
- Technical founders (evaluate on ease of integration, cost, control)

## Internal Team
- 1 backend engineer (Node.js/Postgres)
- 1 frontend engineer (React/docs)
- Founder handles product + marketing (part-time)

questions.md (5 minutes)

# Questions

[What don't you know yet? What needs research or testing?]

Example:

## User Research
- Q1: Do developers prefer self-hosted or SaaS deployment?
  - Research: Survey 30 beta users, analyze pricing page clicks
- Q2: What retention period do users expect (30 days? 90 days? 1 year?)
  - Research: Competitive analysis + user interviews

## Technical
- Q3: Can we handle 100k events/day on a single $50/mo server?
  - Research: Load testing with realistic event payloads
- Q4: Should events be processed sync (real-time) or async (queue)?
  - Decision: Benchmark both, write ADR

## Business
- Q5: Pricing—$9/mo flat or $0.10 per 1k events?
  - Research: Test landing page with both models, track conversion rates

Leave ideas.md and notes.md empty for now—they’ll fill as you work.

Step 4: Create Your Plan (5 minutes)

Extract features from the TRD and organize them into Now/Next/Later:

# Plan

## Now (Shipping This Sprint)
- [ ] Ship JavaScript SDK with event tracking
- [ ] Deploy backend API to production
- [ ] Publish quickstart docs

## Next (Coming After Now)
- [ ] React/Vue integration packages
- [ ] Dashboard UI for viewing analytics
- [ ] Billing integration (Stripe)

## Later (Ideas, Not Committed)
- [ ] Mobile SDK (iOS/Android)
- [ ] Data export API
- [ ] Custom event schemas

Rule: Only put 3-5 items in “Now.” If everything is urgent, nothing is.

Step 5: Start Your First Session (Command Reference)

Use the Makefile commands to start working:

# Start a new project (initial setup)
make project-start

# Start a work session (daily workflow)
make session-start

# End a work session (daily workflow)
make session-end

What `make session-start` Does

Prints the session kickoff prompt:

# Session Kickoff

1. Read `.assistant/status.md` — What's the current focus?
2. Read `.assistant/plan.md` — What's in "Now"?
3. Pick ONE task from backlog to work on today
4. Update status.md with today's focus
5. Start building

What `make session-end` Does

Prints the wrap-up prompt:

# End Session

1. What did you complete today? Update backlog checkboxes
2. What decisions did you make? Write ADRs if needed
3. Update `status.md` changelog with progress
4. Log session in `.assistant/task_log.md` (tool used, args, result)
5. Commit changes with task ID in message

Command Cheat Sheet

# Project lifecycle
make project-start       # Initial TRD → Canvas → Plan → Backlog setup
make session-start       # Begin daily work session
make session-end         # Wrap up and log progress

# Check current state
cat .assistant/status.md        # What's happening now?
cat .assistant/plan.md          # What's the timeline?
cat .assistant/backlog.md       # What tasks exist?

# Reference ADRs
ls .assistant/adr/              # List all decisions
cat .assistant/adr/ADR-003.md   # Read specific decision

Common Setup Mistakes (And How to Fix Them)

Mistake 1: Skipping the Canvas

Problem: You fill the TRD but skip canvas, so nobody aligns on vision/goals/stakeholders.

Fix: Block 30 minutes. Fill vision, goals, stakeholders before you write code.

Mistake 2: Making “Now” Too Big

Problem: You put 20 items in “Now.” Nothing ships because you’re juggling too much.

Fix: Limit “Now” to 3-5 items. Everything else goes in “Next” or “Later.”

Mistake 3: Vague Backlog Items

Problem: Tasks like “Build dashboard” with no acceptance criteria.

Fix: Break it down: “DASH-001: Display total events count from API” with specific checkboxes.

Mistake 4: Forgetting to Update Status

Problem: status.md is stale, so nobody knows what’s happening.

Fix: Run make session-end every time you stop working. Force the habit.

Mistake 5: Writing ADRs for Everything

Problem: You document trivial choices (“Use Prettier for formatting”) and ADR fatigue sets in.

Fix: Only write ADRs for architectural decisions (database, auth strategy, hosting platform). Not code style or implementation details.

FAQ

Q: Do I need all these files? Seems like overkill for a solo project.

A: Start with the essentials:

TRD
vision.md + goals.md
plan.md
backlog.md
status.md

Skip the rest until you need them. But you’ll be surprised how fast “I’ll remember this” turns into “What was I doing again?”

Q: What if I’m already mid-project? Can I adopt this retroactively?

A: Yes. Start by:

Writing a TRD that captures what you’ve built so far + what’s left
Filling status.md with current focus, risks, artifacts
Migrating your to-do list into backlog.md with acceptance criteria
Writing ADRs for major decisions already made (even retroactively)

You’ll lose some context, but future sessions will be clearer.

Q: How does this fit with Agile/Scrum?

A: This is Agile—just documentation-first. Think of it as:

TRD = Product Requirements
Canvas = Sprint Planning context
Plan = Sprint Backlog (Now = current sprint)
Backlog = User Stories with acceptance criteria
Status = Sprint Board / Daily Standup doc

It’s compatible with Scrum, Kanban, or “we just ship stuff.”

Q: What if my team won’t adopt this?

A: Start solo. Use it for your own work. When teammates ask “What’s the status?” or “Why did we choose X?”, point them to status.md or an ADR.

Once they see value, they’ll adopt it. If they don’t… maybe they don’t care about documentation, and that’s telling.

Q: Do I need special tools?

A: No. You need:

Markdown files (any text editor)
Git (version control)
ChatGPT (for generating TRD, optional)
Make (for helper commands, optional)

That’s it. No Jira, no Notion, no Airtable. Just files in your repo.

Q: How often should I update these files?

status.md: Every session (daily if you work daily)
backlog.md: When tasks complete or get added
plan.md: Weekly (move items from Next → Now as you finish)
TRD: When requirements change significantly
Canvas: Monthly or when strategic direction shifts
ADRs: When you make a major technical decision

Tools You’ll Need

Required

Text editor (VS Code, Vim, Sublime, whatever)
Git
Basic shell (bash/zsh)

Optional but Recommended

ChatGPT Plus (for generating TRDs, drafting backlog items)
Make (for helper commands—can also just copy-paste prompts manually)
VS Code Copilot (AI assistance while coding)

Not Needed

JIRA, Asana, Monday.com (tracking happens in markdown)
Notion, Confluence (docs are in your repo)
Miro, FigJam (canvas is just 6 markdown files)

Next Steps

Copy the template into your project
Spend 20 minutes generating a TRD (use the ChatGPT prompt)
Block 30 minutes to fill canvas with your team
Extract 3 items for “Now” in plan.md
Start building (make session-start)

That’s it. You now have:

Clear requirements (TRD)
Strategic alignment (Canvas)
Executable plan (Plan → Backlog)
Progress tracking (Status + Task Log)
Decision history (ADRs)

All in markdown files. Version-controlled. Next to your code.

This template exists because planning in Slack doesn’t work. If you try this approach, I’d love to hear:

What worked?
What felt like overkill?
What did you customize?
What did you skip?

Drop me a note: [email protected]

And if this helps you ship faster, share it with your team. The more people who plan like they ship code, the less time we all waste re-debating decisions or rebuilding features we thought were done.

Series Recap:

Post 1: Stop Planning in Slack — The problem with scattered planning
Post 2: From ChatGPT to Code: The TRD-First Workflow — Generate requirements in 20 minutes
Post 3: Canvas Thinking: Align Before You Build — Strategic context prevents misalignment
Post 4: From Backlog to Done: Tracking Real Progress — Turn plans into shipped work
Post 5: Why We Document Decisions (And How ADRs Save Time) — Capture the “why” before it evaporates
Post 6: Copy This Template and Ship Faster — You are here

Keywords: project template, getting started guide, project setup, agile workflow, developer productivity, project management tutorial

Quick Start (5 Steps, 60 Minutes)

Step 1: Copy the Template (5 minutes)

Step 2: Generate Your TRD Using ChatGPT (20 minutes)

Step 3: Fill the Canvas (30 minutes)

vision.md (10 minutes)

goals.md (10 minutes)

stakeholders.md (5 minutes)

questions.md (5 minutes)

Step 4: Create Your Plan (5 minutes)

Step 5: Start Your First Session (Command Reference)

What make session-start Does

What make session-end Does

Command Cheat Sheet

Common Setup Mistakes (And How to Fix Them)

Mistake 1: Skipping the Canvas

Mistake 2: Making “Now” Too Big

Mistake 3: Vague Backlog Items

Mistake 4: Forgetting to Update Status

Mistake 5: Writing ADRs for Everything

FAQ

Q: Do I need all these files? Seems like overkill for a solo project.

Q: What if I’m already mid-project? Can I adopt this retroactively?

Q: How does this fit with Agile/Scrum?

Q: What if my team won’t adopt this?

Q: Do I need special tools?

Q: How often should I update these files?

Tools You’ll Need

Required

Optional but Recommended

Not Needed

Next Steps

Share Your Experience

What `make session-start` Does

What `make session-end` Does