Semester Assignment Project Development: From Planning to Deployment

One-Line Summary

Starting two weeks before the deadline, combine Claude Code skills step by step to complete requirements analysis → design → implementation → deployment → presentation materials all at once.

Target Audience

• College students who have 2–3 weeks left before a semester project deadline and don't know where to start
• Beginners who have had the experience of "starting to code first and then losing direction"
• Small team project participants who need to split roles and develop in parallel
• Students handling the Next.js / TypeScript / Supabase stack for the first time

---

Core Workflow

Full Timeline (Based on 2 Weeks Before Deadline)

D-14  brainstorming   → Idea generation and requirements gathering
D-13  writing-plans   → Feature list, ERD, component design
D-10  executing-plans → Start implementing core features (parallel)
D-7   subagent split  → Deploy sub-agents per page/API
D-3   ship (draft)    → Staging deployment + QA checklist
D-2   review          → Code review + type error fixes
D-1   land-and-deploy → Production deployment
D-0   document-release → Clean up README and presentation slides

Step 1 — Requirements Analysis (brainstorming)

Paste the professor's assignment description or team idea into a Claude Code session and run the brainstorming skill.

claude
> /skill brainstorming
> Assignment description: "Build a web service to help manage a student club."
> Our team: 4 people, 2 weeks, no stack restrictions.

The brainstorming skill structures ideas using SCAMPER and mind map methods. After the session, save the results to content/raw/brainstorm-[date].md and share with the team.

Example Output:

• 3 core features (notice board, attendance check, file sharing)
• Priority matrix (Must-Have / Nice-to-Have)
• Technology selection rationale (Next.js 15 App Router + Supabase)

Step 2 — Feature Design (writing-plans)

Build a detailed development plan based on the brainstorming results.

> /skill writing-plans
> Based on the brainstorming results above, create a development plan:
> - ERD (notices, users, comments tables)
> - Component tree (based on App Router)
> - API endpoint list
> - Role allocation (2 frontend, 1 backend, 1 infra)

The writing-plans skill generates an execution plan in markdown checkbox format. Saving this file as PLAN.md and committing to GitHub allows all team members to track progress.

Example Output:

## Phase 1: Foundation Setup (D-14 ~ D-12)
- [ ] Initialize Next.js 15 project
- [ ] Create Supabase project + set environment variables
- [ ] Install Tailwind CSS + shadcn/ui

## Phase 2: Core Features (D-11 ~ D-7)
- [ ] Notice CRUD API (Supabase RPC)
- [ ] Notice list page (SSR)
- [ ] Notice detail + comment component
...

Step 3 — Implementation (executing-plans + subagent-driven-development)

Once the plan is ready, use the executing-plans skill to execute items one by one. Delegate complex features to sub-agents with the subagent-driven-development skill.

> /skill executing-plans
> Execute Phase 2 from PLAN.md.
> Start with the first item "Notice CRUD API".

Sub-agent split example (at D-7):

> /skill subagent-driven-development
> Process the following tasks in parallel:
> - Agent A: Notice list page (app/notices/page.tsx)
> - Agent B: Notice detail page (app/notices/[id]/page.tsx)
> - Agent C: Comment API route (app/api/comments/route.ts)

Each sub-agent works within an independent file scope, minimizing Git conflicts. Check results in each agent's session log and merge into the main branch.

Step 4 — QA and Staging Deployment (ship)

At D-3, use the ship skill to automatically generate a pre-deployment checklist.

> /skill ship
> Prepare for Vercel staging deployment.
> Create an environment variable list and a pre-deployment checklist.

Checklist generated by the ship skill:

• [ ] All .env.local entries registered in Vercel environment variables
• [ ] Supabase RLS (Row Level Security) policies enabled
• [ ] next build completes without errors
• [ ] Lighthouse accessibility score 80+
• [ ] Mobile viewport responsiveness verified

Step 5 — Production Deployment (land-and-deploy)

Once staging QA passes, deploy to production with the land-and-deploy skill.

> /skill land-and-deploy
> Staging test complete. Deploy to production (main branch).
> Also create a smoke test script after deployment.

Step 6 — Presentation Materials (document-release)

On the day of the deadline, use the document-release skill to automatically generate presentation documents.

> /skill document-release
> Prepare release notes for this project:
> - Feature summary
> - Tech stack and architecture diagram
> - Team member contribution section

---

Practical Scenario

Situation: Full development of a Student Club Notice Board based on Next.js 15 + TypeScript + Supabase (4-person team, 2 weeks)

D-14: Kickoff Session

# Run Claude Code on the team leader's laptop
claude

# Input assignment description and run brainstorming
> /skill brainstorming
> Professor's assignment: Design, implement, and deploy a web service.
> Our team idea: Student Club Notice Board (writing, comments, file attachments, role-based access control)
> Duration: 14 days, Stack: Next.js 15, TypeScript, Supabase, Tailwind CSS

Output: BRAINSTORM.md (shared with team → reach consensus on feature list)

D-13: Design Session

> /skill writing-plans
> Based on BRAINSTORM.md, design the following:
> 1. Supabase schema (notices, comments, users, roles tables)
> 2. Next.js App Router component tree
> 3. 14-day schedule (including role assignments)

Outputs:

• PLAN.md — checkbox schedule
• schema.sql — Supabase migration file
• ROLES.md — Team role assignments (FrontA / FrontB / Backend / Infra)

D-10 ~ D-7: Parallel Implementation

Each team member implements their assigned feature using executing-plans in their own Claude Code session.

FrontA (Notice list/detail pages):

> /skill executing-plans
> Execute the notice list page items from PLAN.md in order.
> File: app/notices/page.tsx (SSR, Supabase server component)

Backend (API routes):

> /skill executing-plans
> Implement app/api/notices/route.ts.
> GET: list query (pagination), POST: writing (auth required)
> Use Supabase Admin client, comply with TypeScript strict

D-3: QA and Staging

> /skill ship
> Check the current codebase and create a deployment preparation checklist.

# Issues found by ship skill:
# - Missing RLS policy on notices table
# - No file upload size limit
# - No error handling for expired login

D-1: Production Deployment

> /skill land-and-deploy
> Deploy main branch to Vercel production.
> After deployment, run smoke test script with the list of main page URLs

# Automatic smoke test after deployment
> curl -s -o /dev/null -w "%{http_code}" https://club-board.vercel.app/notices
# Expected: 200

D-0: Finalize Presentation Materials

> /skill document-release
> Prepare materials for today's presentation:
> - README.md (feature description + screenshot location guide)
> - ARCHITECTURE.md (tech stack, ASCII system diagram)
> - CHANGELOG.md (feature implementation timeline)

---

Recommended Skill Combinations

Stage	Skill	Role
Idea generation	brainstorming	Extract feature list and priorities
Planning	writing-plans	Generate checkbox schedule and ERD
Sequential implementation	executing-plans	Execute plan items one by one
Parallel development	subagent-driven-development	Split into sub-agents
QA preparation	ship	Pre-deployment checklist
Production deployment	land-and-deploy	Vercel/GitHub Pages deployment
Documentation	document-release	Automate README and presentation materials
Code quality	review	Self-review before PR

---

Cautions

Common Mistakes

1. Starting to code without a plan: Skipping brainstorming and writing-plans causes you to lose direction midway. Investing the first day in design makes the remaining 13 days much more efficient.

2. Sub-agent scope conflicts: When two agents modify the same file during parallel work with subagent-driven-development, conflicts occur. Specify the file scope for each agent in advance.

3. Environment variable management mistakes: Before using the ship skill, always verify that .env.local and Vercel environment variables are synchronized. Missing Supabase URL/Key accounts for 80% of deployment failures.

4. Leaving TypeScript any types: any can be inserted during executing-plans. Specify the no any rule in CLAUDE.md, or always run tsc --noEmit after implementation.

5. Large-scale refactoring the day before the deadline: On D-1, prohibit adding new features or changing structure. Run only ship and land-and-deploy.

Tips

• Use PLAN.md as the team's Single Source of Truth (SSOT): When team members update checkboxes every morning, progress is automatically visualized.
• Save Claude Code session logs: Saving conversation logs from each stage in docs/session-logs/ can serve as explanation material during presentations on "how we developed it."
• Avoid --dangerously-skip-permissions when the deadline is near: The more time pressure there is, the more careful you should be. File overwrite accidents happen most often the day before the deadline.

---

Field	Value
Source URL	https://docs.anthropic.com/en/docs/claude-code
License	CC BY 4.0
Explanation Date	2026-04-12
Author	Claude-Code-Study Project