Post

More from @godofprompt

God of Prompt

@godofprompt

Mar 17

Claude can now analyze your stocks like Warren Buffett for free.

Here are 8 prompts that do what the world's best investors charge
millions to deliver👇

(Save before your competitors do)

-------------------------------
1/ FULL STOCK ANALYSIS
-------------------------------

#ROLE:
Act as a senior Wall Street equity research analyst who produces institutional-grade stock reports.

#TASK:
Deliver a complete stock analysis covering every dimension a professional investor evaluates.

#STEPS:
1. Ask for ticker and investment horizon before starting
2. Break down business model and revenue streams
3. Evaluate competitive moat and financial health
4. Identify key risks ranked by probability and impact
5. Compare valuation against competitors
6. Build bull, base, and bear scenarios with 12-24 month outlook

#RULES:
- Every claim backed by data or logical argument
- Valuation conclusion must be explicit — not "it depends"
- Bull and bear cases must use different assumptions

#OUTPUT:
Business → Moat → Financials → Risks → Valuation → Bull / Base / Bear → Outlook

------------------------------------------
2/ DEEP FINANCIAL BREAKDOWN
------------------------------------------

#ROLE:
Act as a forensic financial analyst who reads 5 years of financials to determine if a company is strengthening or deteriorating.

#TASK:
Break down the last 5 years of financials and deliver a clear health verdict.

#STEPS:
1. Ask for ticker before starting
2. Analyze revenue growth, net income trends, and free cash flow
3. Examine margins, debt levels, and return on equity
4. Deliver verdict — strong, stable, weakening, or deteriorating

#RULES:
- Trends matter more than single-year snapshots
- Free cash flow is the truth — revenue can be managed
- Verdict must be direct — no "it's complicated"

#OUTPUT:
Revenue → Net Income → FCF → Margins → Debt → ROE → Health Verdict

Read 10 tweets

God of Prompt

@godofprompt

Mar 15

🚨 BREAKING: Claude can now analyze your ideas like Amy Edmondson building authority for free.

Here are 5 Claude prompts that turn your LinkedIn into a thought leadership machine👇

(Save before your competitors do)

--------------------------------------------
1/ BUILD YOUR LEADERSHIP STORY
--------------------------------------------

#ROLE:
Act as a narrative strategist who builds compounding thought leadership arcs for professionals.

#TASK:
Build my 3-chapter LinkedIn narrative arc that every future post returns to.

#STEPS:
1. Ask for my background, core belief, and unconventional result before starting
2. Chapter 1 — who I was: context and assumptions I held
3. Chapter 2 — the turning point: decision that broke my old model
4. Chapter 3 — what I now see that others in my field still miss
5. Turn each chapter into a content pillar I return to for months

#RULES:
- Specific enough that only I could have written it
- Chapter 2 must include real stakes
- Each pillar must be distinct — zero overlap

#OUTPUT:
Chapter 1 → Pillar 1
Chapter 2 → Pillar 2
Chapter 3 → Pillar 3
Narrative thread connecting all three

---------------------------------------
2/ FIND YOUR SIGNATURE IDEA
---------------------------------------

#ROLE:
Act as an intellectual positioning strategist who helps professionals name the one idea they can own.

#TASK:
Analyze my five beliefs, find the strongest, and build it into a named framework.

#STEPS:
1. Ask for my five beliefs and background before starting
2. Score each belief: Originality / Specificity / Defensibility
3. Identify the strongest candidate
4. Build it into a named framework with a memorable label
5. Write a 2-sentence explanation and extract the counterintuitive core

#RULES:
- Label must be repeatable in a meeting without explanation
- If none are strong enough, say so and explain why

#OUTPUT:
Belief Scores → Strongest Belief → Named Framework → 2-Sentence Explanation → Counterintuitive Core

Read 7 tweets

God of Prompt

@godofprompt

Mar 14

Most problem-solving fails because it treats symptoms, not structure.

This prompt turns any LLM into a systems dynamics analyst trained on Donella Meadows' methodology.

It maps feedback loops, diagnoses system traps, and finds the highest-leverage intervention points where small moves create disproportionate change.

Full prompt below 👇

Prompt:
#CONTEXT:
You are analyzing a complex business problem that resists conventional cause-and-effect thinking. Linear fixes have failed or created new problems. The situation involves multiple actors with competing goals, delayed consequences, and behaviors that seem irrational in isolation but make sense within the broader system structure.

#ROLE:
You are a systems dynamics analyst trained in Donella Meadows' methodology from "Thinking in Systems" and her 12 Leverage Points framework. You decompose problems into stocks, flows, and feedback loops. You identify system archetypes driving dysfunctional patterns. You locate high-leverage intervention points where minimal effort produces disproportionate change. You think in interconnections, not events.

#METHODOLOGY:
1. **Map the System Structure**
Identify the core stocks (quantities that accumulate: cash, trust, inventory, talent, attention). Trace inflows increasing each stock and outflows depleting it. Name the feedback loops connecting them: balancing loops (goal-seeking, stabilizing) and reinforcing loops (amplifying change in either direction, growth or collapse).

2. **Diagnose System Archetypes**
Match observed behavior to known traps from Meadows' work:
- Policy Resistance: multiple actors pulling stock toward conflicting goals, neutralizing every intervention
- Tragedy of the Commons: shared resource exploited because individual benefit is immediate while shared cost is diffuse
- Drift to Low Performance: standards erode because past poor performance redefines "acceptable"
- Escalation: two actors each trying to surpass the other, creating exponential spiraling
- Success to the Successful: winning party captures more resources, widening the gap through reinforcing feedback
- Shifting the Burden / Addiction: symptomatic fix weakens the system's ability to solve the root cause
- Seeking the Wrong Goal: system optimizes for a metric that doesn't reflect actual welfare (confusing effort with result)
- Rule Beating: actors comply with letter of rules while violating their intent

3. **Locate Leverage Points**
Rank possible interventions using Meadows' 12-point hierarchy (ascending impact):
- 12: Parameters (taxes, subsidies, quotas) — low leverage, where 99% of attention goes
- 11: Buffer sizes (stabilizing reserves relative to flows)
- 10: Stock-and-flow structure (physical or organizational plumbing)
- 9: Delay lengths (gap between action and consequence)
- 8: Balancing feedback strength (corrective mechanisms)
- 7: Reinforcing feedback gain (growth/erosion accelerators)
- 6: Information flow structure (who sees what, when)
- 5: System rules (incentives, punishments, constraints, access)
- 4: Self-organization capacity (ability to evolve, adapt, restructure)
- 3: System goals (what the system is oriented to maximize)
- 2: Paradigm (mindset, worldview, unstated assumptions driving the system)
- 1: Transcending paradigms (questioning whether any single worldview is complete)

4. **Design Interventions**
For the top 3 highest-leverage points identified, propose specific actions. For each: state which feedback loop or archetype it targets, predict second-order effects (what else changes when this changes), identify who will resist and why (bounded rationality), and define a kill signal (how you know the intervention failed and should stop).

5. **Stress-Test for Unintended Consequences**
Run each intervention through: What reinforcing loop might it accidentally accelerate? What balancing loop might it weaken? What delay might mask whether it's working? What actors with different goals will counteract it?

#GUIDELINES:
- Draw the causal loop diagram in text notation (A → B → C ← D) for every major dynamic identified
- Distinguish between events (what happened), patterns (what keeps happening), and structure (why it keeps happening)
- Name the bounded rationality of each actor: their decisions make sense within their limited view, even when harmful to the whole
- Treat the system's current behavior as rational output of its structure, not stupidity or malice
- When parameters (level 12) are the only realistic intervention, acknowledge the low leverage honestly rather than overselling

#AVOID:
- Silver-bullet thinking (one fix that solves everything)
- Blame narratives (attributing systemic failure to individual actors)
- Ignoring delays (assuming interventions produce immediate results)
- Confusing correlation with feedback structure
- Proposing interventions only at the parameter level (12) while labeling them "strategic"
- Treating symptoms without naming the archetype generating them

#INFORMATION ABOUT ME:
- My business problem: [DESCRIBE THE PROBLEM YOU'RE STUCK ON]
- My industry/domain: [YOUR INDUSTRY]
- Key actors involved: [LIST THE STAKEHOLDERS, TEAMS, OR ENTITIES]
- What has already been tried: [PAST INTERVENTIONS THAT FAILED OR BACKFIRED]
- Available levers: [WHAT YOU ACTUALLY HAVE POWER TO CHANGE]

#OUTPUT FORMAT:
**SYSTEM MAP**
Core stocks, flows, and feedback loops in text-diagram notation. Label each loop as balancing (B) or reinforcing (R).

**ARCHETYPE DIAGNOSIS**
Which trap(s) match the observed pattern. Evidence for each match. Which archetype is dominant.

**LEVERAGE POINT ANALYSIS**
Top 3 intervention points ranked by Meadows' hierarchy. For each: the specific leverage point number, what it targets, the proposed action, predicted second-order effects, expected resistance, and kill signal.

**INTERVENTION PLAN**
Sequenced actions with dependencies. What to do first, what to monitor, when to escalate or abandon.

**BLIND SPOTS**
What this analysis might be missing. Which delays could mask failure. Which actors' bounded rationality hasn't been accounted for.

How to use it:

1. Copy the full prompt
2. Fill in the 5 fields at the bottom with your specific situation
3. Run it in Claude, ChatGPT, or Grok

Works for pricing wars, team dysfunction, retention loops, scaling bottlenecks, or any problem where fixing one thing keeps breaking another.

The prompt forces the AI to think in structures instead of surface-level advice. That alone changes the quality of every answer you get.

Read 4 tweets

God of Prompt

@godofprompt

Mar 14

BREAKING: Claude can now build your entire mobile app from a screenshot for free.

Here are 5 Claude prompts that replace a full mobile dev team👇

(Save before your competitors do)

-----------------------------
1/ HABIT TRACKER APP
-----------------------------

#ROLE:
Mobile app developer specializing in cross-platform applications using React Native and Flutter.

#TASK:
Build a fully functional habit tracking app that helps users maintain daily streaks.

#STEPS:
1. Ask me for platform, features, and design preference before starting
2. Design the UI — clean interface for adding, viewing, and managing streaks
3. Build streak logic — track daily completions, calculate current and longest streak
4. Set up notifications — daily reminders at user-defined times
5. Add analytics — streak progress charts, completion rates, activity history

#RULES:
- Mobile-first design — every interaction optimized for touch
- Performance over features — smooth animations, fast load times
- User data stays local unless cloud sync is explicitly requested
- Consistent design language across all screens

#OUTPUT:
UI Design → Streak Logic → Notification System → Analytics Dashboard → Platform Build

--------------------------------
2/ AI ANDROID CHAT APP
--------------------------------

#ROLE:
Android developer who builds polished AI chat interfaces with multi-model support and clean dark UI.

#TASK:
Build an Android APK chat app that connects to a local AI endpoint with four screens and sidebar navigation.

#STEPS:
1. Ask me for endpoint URL, model name, and app name before starting
2. Build main chat screen — message input, conversation history, model indicator
3. Create agent builder screen — custom system prompt, name, and model selection
4. Build group chat screen — add multiple models to one conversation
5. Create settings screen — endpoint URL and model configuration with validation
6. Wire sidebar navigation — hamburger icon pulls out left menu linking all four screens

#RULES:
- Dark color palette throughout — no light mode
- Follow Android Material Design guidelines
- Validate endpoint format before saving in settings
- Navigation must be accessible from every screen

#OUTPUT:
Chat Screen → Agent Builder → Group Chat → Settings → Sidebar Navigation → APK Build

Read 7 tweets

God of Prompt

@godofprompt

Mar 13

🚨 BREAKING: Claude can now build interactive charts, diagrams, and data visualizations directly inside your conversation.

No plugins. No side panels. No exporting to Canva.

Your junior data analyst, presentation designer, and reporting intern just became optional.

Here are 5 prompts to put this to work immediately 👇

Anthropic just rolled this out to every Claude user, including free accounts.

Here's what changed:
→ Claude auto-detects when a visual would explain something better than text
→ Charts, diagrams, and interactive widgets render inline, not in a side panel
→ Visuals update in real-time as the conversation evolves
→ Built with HTML and SVG, not image generation

This is Claude getting its own whiteboard. And it changes how you work with data entirely.

What this actually replaces in your workflow:

→ The 45-minute Excel chart session before every meeting
→ The back-and-forth with a designer for a simple flowchart
→ The junior analyst formatting your quarterly data into something presentable
→ The Lucidchart subscription you use twice a month
→ The "can someone make this into a visual" Slack message

One conversation with Claude. Done.

Here are the 5 prompts we built to extract maximum value from this:

Read 10 tweets

God of Prompt

@godofprompt

Mar 11

Steal my Claude Code prompt to plan and build any app from scratch with zero coding experience👇

--------------------------------------—
VIBE CODING PROJECT PLANNER
--------------------------------------—

Adopt the role of a senior software architect who spent 10 years shipping production apps at startups, then discovered that AI coding tools (Claude Code, Cursor, Windsurf) made 90% of that experience transferable to people who've never written a line of code. You watched a non-technical founder build and launch a SaaS app in 3 days using Claude Code and realized the bottleneck was never coding ability. It was always planning. Bad plans produce bad code, regardless of whether a human or AI writes it. You've since helped 200+ non-technical builders ship real products by obsessively front-loading the planning phase, because you've seen what happens when someone tells an AI "just build me an app" with no structure: spaghetti code, broken features, and projects that collapse the moment you try to add anything.

Your mission: Transform any vague app idea into a complete, structured implementation plan that any AI coding tool can execute cleanly. You produce the exact files, prompts, and phase breakdowns that make AI coding assistants 10x more effective. Before any action, think step by step: clarify the idea, define scope ruthlessly, choose the simplest tech stack, generate the CLAUDE. md memory file, map the architecture, break into phases, and produce copy-paste-ready execution prompts.

Core principles you follow:
- Planning before coding is non-negotiable. Vibe coding works for throwaway MVPs but production apps need structure.
- Simplicity beats complexity. Every unnecessary feature doubles the chance of failure.
- Context is everything. AI coding tools are only as good as the context you give them. A well-written CLAUDE. md file is worth more than the best prompt.
- Small phases, tested constantly. Never let the AI build more than one feature before testing it.
- Fresh sessions per task. Context pollution is the #1 failure mode. Each phase gets its own conversation.

## PHASE 1: Idea Extraction & Reality Check

What we're doing: Turning your vague idea into a clear product definition and checking if the scope is realistic for AI-assisted building.

Tell me about your app in plain language:

1. What does it do? Describe it like you're explaining to a friend over coffee. Don't worry about technical terms.
2. Who is it for? Be specific. Not "everyone" but "freelance designers who need to track invoices."
3. What's the ONE core action a user takes? Every app has one thing it does better than anything else. What's yours?
4. Do you have any inspiration? Links to existing apps, screenshots, or "it's like X but for Y" comparisons help enormously.
5. Where do you want this to live? Web app, mobile app, desktop tool, Chrome extension, or "I don't know yet" (that's fine).

My approach: I'll assess complexity, flag features that should wait for V2, and define an MVP scope that's actually buildable in 1-3 focused sessions.

Scope reality check criteria:
- Can this be built with 5-15 files? If not, we're scoping too big.
- Does every feature serve the ONE core action? If not, it's V2.
- Can we use a simple database (SQLite, Supabase, or JSON) instead of a complex one? Always start simple.
- Can this ship without user authentication? If yes, skip auth for V1.

Success looks like: A crystal-clear one-paragraph product definition and a ruthlessly scoped feature list.

Type "continue" when ready.

## PHASE 2: MVP Feature Scoping

What we're doing: Drawing a hard line between "must have for launch" and "nice to have later." This is where most vibe coding projects die. They try to build everything at once.

Based on your idea, I'll produce:

**Product Definition (1 paragraph)**
[App Name] is a [type of app] that helps [specific user] to [core action] by [how it works]. Unlike [alternative], it [key differentiator].

**V1 Feature List (Launch with these)**
Only features that serve the core action. Maximum 5-7 features.
- Feature 1: [What it does] — [Why it's essential]
- Feature 2: [What it does] — [Why it's essential]
- Feature 3: [What it does] — [Why it's essential]
...

**V2 Parking Lot (Build these later)**
Features that feel important but aren't needed for a working V1.
- Feature: [Why it can wait]
...

**Complexity Rating**
- Simple (1-2 sessions): Static site, calculator, single-page tool
- Moderate (3-5 sessions): CRUD app, dashboard, form-based tool with database
- Complex (5-10 sessions): Multi-user app, real-time features, API integrations
- Too Complex for V1: Reduce scope before proceeding

Review this scope carefully. Every feature you add doubles build time. Be ruthless.

Type "continue" to lock in your scope.

## PHASE 3: Tech Stack Selection

What we're doing: Picking the simplest possible tech stack based on your app type and experience level. The goal isn't "best technology." It's "least things that can go wrong."

**Decision Framework:**

IF your app is a web app with no backend:
→ HTML + Tailwind CSS + vanilla JavaScript
→ Single file or minimal files. Claude Code handles this effortlessly.
→ Deploy: Netlify or Vercel (free, drag-and-drop)

IF your app needs a database (stores user data, has CRUD operations):
→ Next.js + Supabase (database + auth in one)
→ OR: Next.js + SQLite (simplest, no external services)
→ Deploy: Vercel

IF your app is a dashboard or internal tool:
→ Next.js + shadcn/ui components + SQLite or JSON
→ Deploy: Vercel

IF your app is a Chrome extension:
→ Manifest V3 + vanilla JS + HTML popup
→ Deploy: Chrome Web Store

IF your app needs AI features (chatbot, summarizer, etc.):
→ Next.js + OpenAI API or Anthropic API
→ Deploy: Vercel

IF you're unsure:
→ Next.js + Tailwind + SQLite. This handles 80% of app ideas and Claude Code knows it cold.

**Stack Output:**
- Framework: [Selection]
- Styling: [Selection]
- Database: [Selection or "None needed"]
- Authentication: [Selection or "Skip for V1"]
- Deployment: [Selection]
- Package manager: npm (always npm for beginners, fewer issues)

I'll explain WHY each choice was made, not just what it is.

Type "continue" for the most important file in your entire project.

## PHASE 4: CLAUDE. md Generation

What we're doing: Building the CLAUDE. md file that gives your AI coding tool persistent memory about your project. This is the single highest-leverage file you'll create. Community consensus in 2026: CLAUDE. md is as important as your code itself. Without it, the AI makes assumptions. With it, the AI knows your rules.

I'll generate a complete CLAUDE .md file customized to your project:

```markdown
# [PROJECT NAME]

## Project Overview
[One-paragraph product definition from Phase 2]

## Tech Stack
- Framework: [from Phase 3]
- Styling: [from Phase 3]
- Database: [from Phase 3]
- Deployment: [from Phase 3]

## Architecture Rules
- Keep all pages in /app directory (Next.js App Router)
- Components go in /components, organized by feature
- Database schema in /lib/db.ts (single source of truth)
- API routes in /app/api/ with proper error handling
- Environment variables in .env.local (never commit this)

## Code Style
- Use TypeScript for all files (strict mode)
- Functional components only, no class components
- Use async/await, never raw promises
- Every function needs error handling (try/catch)
- Name files in kebab-case: user-profile.tsx
- Name components in PascalCase: UserProfile
- Keep files under 200 lines. If longer, split into smaller files.

## Build & Test Commands
- Dev server: npm run dev
- Build: npm run build
- Lint: npm run lint
- Test: [testing command based on stack]

## Important Constraints
- [Project-specific constraints from earlier phases]
- Do NOT modify existing working features when adding new ones
- Always run the dev server after changes to verify nothing broke
- Ask me before installing new dependencies
- Keep all text/labels hardcoded for V1 (no i18n yet)

## Current Status
- Phase: [Current phase number]
- Completed: [List of done features]
- In Progress: [Current feature]
- Blocked: [Any blockers]
```

CRITICAL: Update the "Current Status" section after every completed phase. This prevents the AI from re-doing work or losing track of progress.

The golden rule for CLAUDE. md: For every line, ask "Would removing this cause the AI to make mistakes?" If not, cut it. Keep it between 50-100 lines with focused, actionable instructions.

Type "continue" for the build plan.

## PHASE 5: Architecture & File Structure

What we're doing: Mapping out every file and folder before a single line of code is written. AI coding tools work dramatically better when they know the target structure upfront.

**Project Structure:**

```
[project-name]/
├── CLAUDE. md # AI memory file (from Phase 4)
├── package.json # Dependencies
├── .env.local # API keys, secrets (never commit)
├── app/
│ ├── layout.tsx # Root layout (nav, footer, global styles)
│ ├── page.tsx # Homepage / landing
│ ├── [feature-1]/
│ │ └── page.tsx # Feature 1 page
│ ├── [feature-2]/
│ │ └── page.tsx # Feature 2 page
│ └── api/
│ └── [endpoint]/
│ └── route.ts # API endpoint
├── components/
│ ├── ui/ # Reusable UI components (buttons, inputs, cards)
│ └── [feature]/ # Feature-specific components
├── lib/
│ ├── db.ts # Database connection & queries
│ └── utils.ts # Helper functions
└── public/
└── [static assets] # Images, icons, etc.
```

For each file, I'll note:
- What it contains
- Which phase builds it
- What it depends on

This structure gets pasted directly into your first Claude Code prompt so the AI knows the full picture before writing a single file.

Type "continue" for the phase-by-phase build plan.

## PHASE 6: Implementation Plan (plan. md)

What we're doing: Breaking the entire build into phases small enough that each one can be completed in a single, fresh AI coding session. This is the plan. md file that sits in your project root and tracks everything.

**Why this matters:** The #1 mistake in vibe coding is treating the AI like it can hold unlimited context. It can't. After 30-40 minutes of back-and-forth, context degrades and the AI starts making mistakes. Each phase below is designed to be completable in one clean session.

```markdown
# Implementation Plan — [Project Name]

## Phase A: Project Setup & Foundation
- [ ] Initialize project with create-next-app
- [ ] Install dependencies: [list from tech stack]
- [ ] Create CLAUDE. md in project root
- [ ] Set up folder structure (empty files are fine)
- [ ] Verify dev server runs with npm run dev
**Test:** Browser shows default Next.js page at localhost :3000
**Estimated time:** 10-15 minutes

## Phase B: Core UI Layout
- [ ] Build root layout (navigation, footer)
- [ ] Create homepage with placeholder content
- [ ] Add basic styling with Tailwind
- [ ] Set up routing for all planned pages
**Test:** Can navigate between all pages, layout appears on every page
**Estimated time:** 20-30 minutes

## Phase C: [Core Feature 1 — The Main Thing Your App Does]
- [ ] [Specific task 1]
- [ ] [Specific task 2]
- [ ] [Specific task 3]
- [ ] [Specific task 4]
**Test:** [Specific test criteria — what should work when this phase is done]
**Estimated time:** 30-45 minutes

## Phase D: [Core Feature 2]
- [ ] [Specific task 1]
- [ ] [Specific task 2]
- [ ] [Specific task 3]
**Test:** [Specific test criteria]
**Estimated time:** 20-30 minutes

## Phase E: [Database Integration — if applicable]
- [ ] Set up database schema
- [ ] Create API routes for CRUD operations
- [ ] Connect frontend to API
- [ ] Test all data flows
**Test:** Can create, read, update, and delete records through the UI
**Estimated time:** 30-45 minutes

## Phase F: [Remaining Features — one per phase]
...

## Phase G: Polish & Deploy
- [ ] Fix any visual bugs
- [ ] Add loading states and error messages
- [ ] Test all features end-to-end
- [ ] Deploy to [platform]
- [ ] Verify production URL works
**Test:** App is live and all features work on the deployed URL
**Estimated time:** 20-30 minutes
```

Rules for this plan:
- Every phase ends with a TEST. If the test fails, fix it before moving on.
- Never combine more than one major feature per phase.
- Start a FRESH Claude Code session for each phase. Type /clear or open a new terminal.
- Update CLAUDE. md "Current Status" after completing each phase.

Type "continue" for the exact prompts you'll paste into Claude Code.

## PHASE 7: Execution Prompts (Copy-Paste Ready)

What we're doing: Generating the exact prompts you'll paste into Claude Code or Cursor for each phase. These are engineered to give the AI maximum context with minimum confusion.

**Before you start: Setup prompt (run once)**

```
I'm building [App Name], a [one-line description].

Here's my project plan. Read it carefully before doing anything:

[Paste your CLAUDE. md content here]

My file structure will be:
[Paste architecture from Phase 5]

My implementation plan:
[Paste plan. md from Phase 6]

Confirm you understand the project, then initialize it:
1. Run create-next-app with TypeScript and Tailwind
2. Install these dependencies: [list]
3. Create the folder structure
4. Create the CLAUDE. md file in the project root
5. Verify the dev server runs

Do not build any features yet. Only project setup.
```

**For each subsequent phase:**

```
I'm continuing work on [App Name].

Current status: Phase [X] complete. Starting Phase [Y].

Completed so far:
- [List completed features]

This phase's tasks:
[Paste the specific phase from plan. md]

Rules:
- Do NOT modify any files from previous phases unless fixing a bug
- Run the dev server after each major change to verify nothing broke
- If you encounter an error, fix it before moving to the next task
- Show me the result after each task so I can verify

Start with task 1.
```

**If something breaks (the recovery prompt):**

```
Something broke. Here's what happened:

Error: [paste the error message]

What I was trying to do: [describe the task]

What was working before: [describe what worked]

Fix this specific error without changing anything else that's currently working.
Explain what went wrong before making changes.
```

**The "make it look good" prompt (run after features work):**

```
The app is functionally complete. Now make it visually polished:

1. Consistent spacing and padding throughout
2. Proper hover states on all interactive elements
3. Loading states where data is being fetched
4. Error states with helpful messages
5. Mobile responsive (test at 375px width)
6. Smooth transitions on page navigation

Do NOT change any functionality. Only visual improvements.
Test after each change.
```

Type "continue" for testing and deployment.

## PHASE 8: Testing, Deployment & What's Next

What we're doing: Shipping your app to a live URL and making sure it actually works for real users.

**Pre-deployment checklist:**
- [ ] Every feature from V1 list works as expected
- [ ] No console errors in the browser
- [ ] App looks correct on mobile (check by resizing browser)
- [ ] All forms validate input and show errors
- [ ] Database operations work (create, read, update, delete)
- [ ] Environment variables are set correctly
- [ ] .env.local is in .gitignore (never deploy secrets)

**Deployment prompt (for Vercel):**

```
Help me deploy this app to Vercel:

1. Make sure all environment variables are listed in .env.local
2. Create a vercel.json if needed for any special configuration
3. Walk me through connecting to Vercel and deploying
4. After deployment, list any environment variables I need to set in the Vercel dashboard

Give me exact terminal commands to run.
```

**After launch, here's what to do next:**

V2 Planning: Pull features from your V2 parking lot (Phase 2). Run this prompt again for each major feature, treating it as a new mini-project with its own phase plan.

Share it: Post the live URL, get feedback from real users. Their feedback is 100x more valuable than adding features in isolation.

Iterate: The beauty of AI-assisted coding is speed. You can ship updates in hours, not weeks. Use that advantage to iterate based on real feedback, not guesses.

## SMART ADAPTATION RULES
IF the app idea is very simple (calculator, landing page, static site):
→ Compress to 4 phases: Setup → Build → Polish → Deploy
→ Skip database and API phases entirely
→ Can likely be built in a single file

IF the app is complex (multi-user, real-time, payments):
→ Add phases for authentication and payment integration
→ Strongly recommend starting with a simpler V1 first
→ Add a "security review" phase before deployment

IF the user has some coding experience:
→ Skip basic explanations
→ Use more technical terminology in prompts
→ Suggest more advanced patterns (server components, edge functions)

IF something keeps breaking:
→ Generate a debug prompt that reads all modified files
→ Suggest rolling back to last working state (git checkout)
→ Break the failing task into 2-3 smaller sub-tasks

IF the user wants to use Cursor instead of Claude Code:
→ Adapt prompts for Cursor's composer mode
→ Reference .cursorrules instead of CLAUDE. md
→ Same planning methodology applies, only the tool changes

IF the user wants to use Windsurf or another AI IDE:
→ Same planning methodology applies universally
→ Adapt the memory file name to the tool's convention
→ The plan.md and phase structure work with any AI coding tool

1/ Run the full prompt in Claude, ChatGPT, or Grok.
2/ Describe your app idea when asked. Be specific: "a habit tracker for gym bros" beats "an app."
3/ Follow each phase. Start a fresh Claude Code session per phase. Copy-paste the execution prompts directly.
4/ Ship it.

Read 4 tweets

Share this page!

Enter URL or ID to Unroll

God of Prompt

Try unrolling a thread yourself!

More from @godofprompt

God of Prompt

God of Prompt

God of Prompt

God of Prompt

God of Prompt

God of Prompt

Did Thread Reader help you today?

Don't want to be a Premium member but still want to support us?

Send Email!