Get Shit Done

1. Działaj szybko, iteruj jeszcze szybciej
2. Perfekcja to wróg postępu
3. AI robi commodity work, Ty robisz creative work
4. Feedback > planowanie
5. Ship today, improve tomorrow
6. Context is king
7. Każdy problem ma szybkie rozwiązanie

❌ "Let me plan the perfect architecture first..."
✅ "Create a basic version that works, then improve"

❌ "I need to research all possible approaches..."
✅ "Try the simplest approach, pivot if needed"

❌ "This needs to be scalable from day one..."
✅ "Make it work for 10 users, then 100, then 1000"

// Zamiast projektować idealny system autoryzacji...

// Krok 1: Zrób najprostszą rzecz która działa
const isAdmin = (userId: string) => userId === process.env.ADMIN_ID

// Krok 2: Gdy potrzebujesz więcej, rozszerz
const hasPermission = (userId: string, permission: string) => {
  const user = await getUser(userId)
  return user.permissions.includes(permission)
}

// Krok 3: Gdy potrzebujesz RBAC, przebuduj
// ... ale dopiero gdy naprawdę potrzebujesz

❌ Pisz boilerplate ręcznie
✅ "Generate CRUD for User model with validation"

❌ Ręcznie konwertuj typy
✅ "Generate TypeScript types from this JSON"

❌ Pisz dokumentację od zera
✅ "Add JSDoc comments to these functions"

❌ Ręcznie refaktoruj
✅ "Refactor this to use async/await instead of callbacks"

❌ "Fix the bug"
✅ "Fix the null pointer in useAuth.ts:45.
    The user object is undefined when session expires.
    Expected: Show login modal. Actual: White screen."

❌ "Add tests"
✅ "Add unit tests for calculateDiscount function in pricing.ts.
    Cover: normal price, bulk discount (>10 items),
    VIP discount, combined discounts, edge cases (0, negative)."

❌ "Make it better"
✅ "Optimize this query - currently takes 2s for 10k rows.
    Table has indexes on user_id and created_at.
    Most queries filter by user_id + date range."

## Task
[Co chcesz osiągnąć]

## Context
[Relevantne informacje o kodzie/projekcie]

## Current State
[Jak to działa teraz]

## Expected State
[Jak ma działać]

## Constraints
[Ograniczenia, technologie, patterns]

## Task
Add pagination to the products list

## Context
- Next.js 15 App Router
- PostgreSQL + Prisma
- Currently fetching all products (slow for 10k+ items)

## Current State
\`\`\`typescript
const products = await prisma.product.findMany()
\`\`\`

## Expected State
- Server-side pagination
- 20 items per page
- URL-based page state (?page=2)
- Total count for pagination UI

## Constraints
- Keep as Server Component
- Use existing Prisma setup
- Match current UI design (shadcn/ui)

Standard flow:
1. Opisz co chcesz (30 sekund)
2. AI generuje kod (10 sekund)
3. Testuj natychmiast (60 sekund)
4. Feedback do AI (30 sekund)
5. Repeat

Cykl: ~2 minuty per iteracja
10 iteracji: 20 minut do working feature

1. Zaplanuj architekturę (2 godziny)
2. Napisz kod (4 godziny)
3. Debug (2 godziny)
4. Refactor (2 godziny)
5. Test (1 godzina)

Total: ~11 godzin do working feature

Day 1: Ship working MVP
Day 2: Fix critical bugs from user feedback
Day 3: Add most requested feature
Day 7: Refactor based on real usage patterns
Day 30: Optimize performance bottlenecks

NIE:
Month 1: Plan perfect architecture
Month 2: Build perfect architecture
Month 3: Realize users wanted something else

❌ "This will take weeks to implement properly"
✅ "What's the fastest way to validate this idea?"

❌ "We need a custom solution"
✅ "Is there a library/service that does 80% of this?"

❌ "This requires a complex algorithm"
✅ "What's the naive solution? Is it good enough?"

1. Czy istnieje gotowa biblioteka? → Użyj jej
2. Czy można użyć SaaS? → Zintegruj
3. Czy naive solution wystarczy? → Zaimplementuj
4. Czy AI może wygenerować? → Deleguj
5. Dopiero wtedy → Buduj custom

# 1. Review what needs to be done
cat TODO.md  # or check Linear/Notion

# 2. Pick ONE high-impact item
# Ask: "What will move the needle most today?"

# 3. Time-box it
# "I'll spend max 2 hours on this"

# 4. Start Claude Code
claude

[0:00-0:05] Define the task clearly
[0:05-0:10] Gather context (files, errors, requirements)
[0:10-0:50] Iterate with AI (5-10 cycles)
[0:50-0:55] Test thoroughly
[0:55-1:00] Commit and document

Break 10 min

Repeat

Implement [feature] that:
- Does X
- Handles Y edge case
- Uses existing [pattern] from [file]
- Follows our conventions (TypeScript strict, Tailwind, etc.)

Start with the simplest working version.

Debug [issue]:
- Expected: [behavior]
- Actual: [behavior]
- Steps to reproduce: [steps]
- Relevant code: [file:line]
- Error message: [error]

I've already tried: [attempts]

Refactor [code] to:
- Improve [specific aspect]
- Maintain backward compatibility
- Keep same public API

Don't change: [what to preserve]
Constraints: [limits]

Review this code for:
- Bugs and edge cases
- Security issues
- Performance problems
- Code quality

Be critical. I want to ship this today.

// 1. Generate types from API response
"Generate TypeScript interfaces from this JSON response"

// 2. Write tests for existing code
"Write unit tests for this function, cover edge cases"

// 3. Add error handling
"Add proper error handling with user-friendly messages"

// 4. Optimize component
"This component re-renders too often, optimize it"

// 5. Add loading states
"Add loading and error states to this data-fetching component"

// 6. Create form from schema
"Generate a form component from this Zod schema"

// 7. Add documentation
"Add JSDoc comments to exported functions in this file"

// 8. Convert patterns
"Convert this callback-based code to async/await"

// 9. Add validation
"Add input validation using Zod for this API endpoint"

// 10. Create tests
"Generate test cases for this function based on its types"

Code:        Claude Code / Cursor
UI:          v0.dev → shadcn/ui
Backend:     Supabase / Convex / Firebase
Deploy:      Vercel / Railway
Auth:        Clerk / NextAuth
Payments:    Stripe
Analytics:   Plausible / PostHog
Monitoring:  Sentry

# .bashrc / .zshrc

# Quick Claude Code
alias c="claude"
alias cc="claude --continue"

# Quick git
alias gs="git status"
alias gc="git commit -m"
alias gp="git push"
alias gcp="git add -A && git commit -m 'wip' && git push"

# Quick npm
alias d="npm run dev"
alias b="npm run build"
alias t="npm test"

# Quick directories
alias p="cd ~/projects"

✅ Features shipped per week
✅ Time to first working version
✅ User feedback response time
✅ Bugs caught before production
✅ Iteration cycles per feature

❌ Lines of code written
❌ Hours worked
❌ Commits per day
❌ Test coverage %
❌ Code complexity metrics

## Week of [Date]

### Shipped
- [ ] Feature A (impact: high, effort: medium)
- [ ] Fix B (impact: medium, effort: low)
- [ ] Improvement C (impact: low, effort: low)

### Learnings
- What worked well:
- What slowed me down:
- What to try next week:

### Blockers removed
- [blocker] → [solution]

### Next week priorities
1. [Most impactful item]
2. [Second priority]
3. [Nice to have]

Old: "This code needs to be perfect before I ship"
New: "This code needs to work before I ship"

Old: "I'll add all features users might need"
New: "I'll add features users actually ask for"

Old: "Let me research the best approach"
New: "Let me try the simplest approach"

Old: "Let me write a detailed spec first"
New: "Let me build a prototype first"

Old: "We need a meeting to discuss this"
New: "Let me try it and show you the result"

Old: "I'll estimate how long this will take"
New: "I'll time-box it and see how far I get"

Old: "I need to figure this out myself"
New: "Let me ask AI for options, then decide"

Old: "Writing tests is tedious"
New: "AI writes tests, I review them"

Old: "Documentation takes forever"
New: "AI documents, I verify accuracy"

"Done is better than perfect"
"Ship today, improve tomorrow"
"AI handles breadth, you handle depth"
"Every problem has a fast solution"
"Progress over perfection"
"Feedback over speculation"
"Working code beats documentation"

Problem: Walidacja pomysłu na SaaS

Friday evening:
- Idea: Tool do śledzenia nawyków
- Stack: Next.js + Supabase + Vercel

Saturday:
- Morning: Auth + basic data model (Supabase)
- Afternoon: Core UI (v0 → shadcn/ui)
- Evening: CRUD operations + basic charts

Sunday:
- Morning: Polish UI, add onboarding
- Afternoon: Set up Stripe (simple pricing)
- Evening: Deploy to Vercel, buy domain

Monday:
- Share na Twitter, ProductHunt, Reddit
- First 10 users signed up
- Real feedback started flowing

Total: ~20 hours to shipped MVP

Problem: Add export to PDF dla raportów

Traditional approach (estimated: 2 days):
- Research PDF libraries
- Design export format
- Implement generation
- Handle edge cases
- Test thoroughly

GSD approach (actual: 1 hour):

[0:00] "Add PDF export to this report component.
       Use react-pdf or similar. Match current styling."

[0:10] AI generates working version

[0:20] Test with real data, find edge cases

[0:30] "Fix: long text overflows, images missing"

[0:40] Iterate 2 more times

[0:50] Final testing

[1:00] Commit and deploy

Result: Users can export PDFs

Faza 1 (MVP): 100% GSD
Faza 2 (PMF): 70% GSD, 30% engineering
Faza 3 (Scale): 50% GSD, 50% engineering
Faza 4 (Mature): 30% GSD, 70% engineering

1. Act fast, iterate even faster
2. Perfection is the enemy of progress
3. AI does commodity work, you do creative work
4. Feedback > planning
5. Ship today, improve tomorrow
6. Context is king
7. Every problem has a fast solution

❌ "Let me plan the perfect architecture first..."
✅ "Create a basic version that works, then improve"

❌ "I need to research all possible approaches..."
✅ "Try the simplest approach, pivot if needed"

❌ "This needs to be scalable from day one..."
✅ "Make it work for 10 users, then 100, then 1000"

// Instead of designing a perfect authorization system...

// Step 1: Do the simplest thing that works
const isAdmin = (userId: string) => userId === process.env.ADMIN_ID

// Step 2: When you need more, extend
const hasPermission = (userId: string, permission: string) => {
  const user = await getUser(userId)
  return user.permissions.includes(permission)
}

// Step 3: When you need RBAC, rebuild
// ... but only when you actually need it

❌ Write boilerplate manually
✅ "Generate CRUD for User model with validation"

❌ Convert types by hand
✅ "Generate TypeScript types from this JSON"

❌ Write documentation from scratch
✅ "Add JSDoc comments to these functions"

❌ Refactor manually
✅ "Refactor this to use async/await instead of callbacks"

❌ "Fix the bug"
✅ "Fix the null pointer in useAuth.ts:45.
    The user object is undefined when session expires.
    Expected: Show login modal. Actual: White screen."

❌ "Add tests"
✅ "Add unit tests for calculateDiscount function in pricing.ts.
    Cover: normal price, bulk discount (>10 items),
    VIP discount, combined discounts, edge cases (0, negative)."

❌ "Make it better"
✅ "Optimize this query - currently takes 2s for 10k rows.
    Table has indexes on user_id and created_at.
    Most queries filter by user_id + date range."

## Task
[What you want to achieve]

## Context
[Relevant information about the code/project]

## Current State
[How it works now]

## Expected State
[How it should work]

## Constraints
[Limitations, technologies, patterns]

## Task
Add pagination to the products list

## Context
- Next.js 15 App Router
- PostgreSQL + Prisma
- Currently fetching all products (slow for 10k+ items)

## Current State
\`\`\`typescript
const products = await prisma.product.findMany()
\`\`\`

## Expected State
- Server-side pagination
- 20 items per page
- URL-based page state (?page=2)
- Total count for pagination UI

## Constraints
- Keep as Server Component
- Use existing Prisma setup
- Match current UI design (shadcn/ui)

Standard flow:
1. Describe what you want (30 seconds)
2. AI generates code (10 seconds)
3. Test immediately (60 seconds)
4. Feedback to AI (30 seconds)
5. Repeat

Cycle: ~2 minutes per iteration
10 iterations: 20 minutes to a working feature

1. Plan architecture (2 hours)
2. Write code (4 hours)
3. Debug (2 hours)
4. Refactor (2 hours)
5. Test (1 hour)

Total: ~11 hours to a working feature

Day 1: Ship working MVP
Day 2: Fix critical bugs from user feedback
Day 3: Add most requested feature
Day 7: Refactor based on real usage patterns
Day 30: Optimize performance bottlenecks

NOT:
Month 1: Plan perfect architecture
Month 2: Build perfect architecture
Month 3: Realize users wanted something else

❌ "This will take weeks to implement properly"
✅ "What's the fastest way to validate this idea?"

❌ "We need a custom solution"
✅ "Is there a library/service that does 80% of this?"

❌ "This requires a complex algorithm"
✅ "What's the naive solution? Is it good enough?"

1. Is there a ready-made library? → Use it
2. Can you use a SaaS? → Integrate it
3. Is a naive solution good enough? → Implement it
4. Can AI generate it? → Delegate
5. Only then → Build custom

# 1. Review what needs to be done
cat TODO.md  # or check Linear/Notion

# 2. Pick ONE high-impact item
# Ask: "What will move the needle most today?"

# 3. Time-box it
# "I'll spend max 2 hours on this"

# 4. Start Claude Code
claude

[0:00-0:05] Define the task clearly
[0:05-0:10] Gather context (files, errors, requirements)
[0:10-0:50] Iterate with AI (5-10 cycles)
[0:50-0:55] Test thoroughly
[0:55-1:00] Commit and document

Break 10 min

Repeat

Implement [feature] that:
- Does X
- Handles Y edge case
- Uses existing [pattern] from [file]
- Follows our conventions (TypeScript strict, Tailwind, etc.)

Start with the simplest working version.

Debug [issue]:
- Expected: [behavior]
- Actual: [behavior]
- Steps to reproduce: [steps]
- Relevant code: [file:line]
- Error message: [error]

I've already tried: [attempts]

Refactor [code] to:
- Improve [specific aspect]
- Maintain backward compatibility
- Keep same public API

Don't change: [what to preserve]
Constraints: [limits]

Review this code for:
- Bugs and edge cases
- Security issues
- Performance problems
- Code quality

Be critical. I want to ship this today.

// 1. Generate types from API response
"Generate TypeScript interfaces from this JSON response"

// 2. Write tests for existing code
"Write unit tests for this function, cover edge cases"

// 3. Add error handling
"Add proper error handling with user-friendly messages"

// 4. Optimize component
"This component re-renders too often, optimize it"

// 5. Add loading states
"Add loading and error states to this data-fetching component"

// 6. Create form from schema
"Generate a form component from this Zod schema"

// 7. Add documentation
"Add JSDoc comments to exported functions in this file"

// 8. Convert patterns
"Convert this callback-based code to async/await"

// 9. Add validation
"Add input validation using Zod for this API endpoint"

// 10. Create tests
"Generate test cases for this function based on its types"

Code:        Claude Code / Cursor
UI:          v0.dev → shadcn/ui
Backend:     Supabase / Convex / Firebase
Deploy:      Vercel / Railway
Auth:        Clerk / NextAuth
Payments:    Stripe
Analytics:   Plausible / PostHog
Monitoring:  Sentry

# .bashrc / .zshrc

# Quick Claude Code
alias c="claude"
alias cc="claude --continue"

# Quick git
alias gs="git status"
alias gc="git commit -m"
alias gp="git push"
alias gcp="git add -A && git commit -m 'wip' && git push"

# Quick npm
alias d="npm run dev"
alias b="npm run build"
alias t="npm test"

# Quick directories
alias p="cd ~/projects"

✅ Features shipped per week
✅ Time to first working version
✅ User feedback response time
✅ Bugs caught before production
✅ Iteration cycles per feature

❌ Lines of code written
❌ Hours worked
❌ Commits per day
❌ Test coverage %
❌ Code complexity metrics

## Week of [Date]

### Shipped
- [ ] Feature A (impact: high, effort: medium)
- [ ] Fix B (impact: medium, effort: low)
- [ ] Improvement C (impact: low, effort: low)

### Learnings
- What worked well:
- What slowed me down:
- What to try next week:

### Blockers removed
- [blocker] → [solution]

### Next week priorities
1. [Most impactful item]
2. [Second priority]
3. [Nice to have]

Old: "This code needs to be perfect before I ship"
New: "This code needs to work before I ship"

Old: "I'll add all features users might need"
New: "I'll add features users actually ask for"

Old: "Let me research the best approach"
New: "Let me try the simplest approach"

Old: "Let me write a detailed spec first"
New: "Let me build a prototype first"

Old: "We need a meeting to discuss this"
New: "Let me try it and show you the result"

Old: "I'll estimate how long this will take"
New: "I'll time-box it and see how far I get"

Old: "I need to figure this out myself"
New: "Let me ask AI for options, then decide"

Old: "Writing tests is tedious"
New: "AI writes tests, I review them"

Old: "Documentation takes forever"
New: "AI documents, I verify accuracy"

"Done is better than perfect"
"Ship today, improve tomorrow"
"AI handles breadth, you handle depth"
"Every problem has a fast solution"
"Progress over perfection"
"Feedback over speculation"
"Working code beats documentation"

Problem: Validating a SaaS idea

Friday evening:
- Idea: Habit tracking tool
- Stack: Next.js + Supabase + Vercel

Saturday:
- Morning: Auth + basic data model (Supabase)
- Afternoon: Core UI (v0 → shadcn/ui)
- Evening: CRUD operations + basic charts

Sunday:
- Morning: Polish UI, add onboarding
- Afternoon: Set up Stripe (simple pricing)
- Evening: Deploy to Vercel, buy domain

Monday:
- Share on Twitter, ProductHunt, Reddit
- First 10 users signed up
- Real feedback started flowing

Total: ~20 hours to shipped MVP

Problem: Add PDF export for reports

Traditional approach (estimated: 2 days):
- Research PDF libraries
- Design export format
- Implement generation
- Handle edge cases
- Test thoroughly

GSD approach (actual: 1 hour):

[0:00] "Add PDF export to this report component.
       Use react-pdf or similar. Match current styling."

[0:10] AI generates working version

[0:20] Test with real data, find edge cases

[0:30] "Fix: long text overflows, images missing"

[0:40] Iterate 2 more times

[0:50] Final testing

[1:00] Commit and deploy

Result: Users can export PDFs

Phase 1 (MVP): 100% GSD
Phase 2 (PMF): 70% GSD, 30% engineering
Phase 3 (Scale): 50% GSD, 50% engineering
Phase 4 (Mature): 30% GSD, 70% engineering