Post

https://twitter.com/1643695629665722379/status/2023703456549306493

More from @godofprompt

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

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 13

My client asked for a full brand strategy.

3 weeks. $8,000 budget.

I opened Claude.
Pasted one mega-prompt.
Had the entire strategy in 14 minutes.

Here are the prompts that replaced the process 👇

(Save for later)

--------------------------------------------------
1/ WEBSITE ARCHITECTURE STRATEGIST
--------------------------------------------------

#ROLE:
Senior solutions architect who blueprints web systems before a line of code gets written.

#TASK:
Build a complete architectural blueprint for my website.

#STEPS:
1. Map site structure — full page hierarchy
2. Trace 3 user flows from entry to conversion
3. Define data models and dynamic content needs
4. List API requirements — endpoints and auth
5. Build component inventory — 30+ items
6. Recommend tech stack with rationale
7. Set performance budgets — LCP, bundle size, Core Web Vitals
8. Structure SEO — URL schema, meta strategy, crawl priorities

#RULES:
- Every recommendation ties to the audience
- Performance budgets must include concrete numbers
- No vague recommendations — pick one approach

#INFORMATION ABOUT ME:
- Website type: [SAAS / E-COMMERCE / PORTFOLIO / OTHER]
- Target audience: [DESCRIBE]
- Core features: [LIST 3-5]
- Priorities: [RESPONSIVE / SEO / PERFORMANCE]

#OUTPUT:
Site Map → User Flows → Data Models → API Requirements → Component Inventory → Tech Stack → Performance Budgets → SEO Structure

----------------------------------------
2/ DESIGN SYSTEM GENERATOR
----------------------------------------

#ROLE:
Design systems lead who builds token-based systems that scale across products.

#TASK:
Generate a complete, production-ready design system for my brand.

#STEPS:
1. Build color palette — primary, secondary, semantic, dark mode
2. Define 9-level typography scale with usage rules
3. Create 8px spacing system with named scale
4. Spec 30 components — all states included
5. Define breakpoint layout patterns
6. Document animation guidelines — durations and easing curves
7. Map WCAG AA requirements throughout

#RULES:
- Every token gets a semantic name, not a raw value
- Dark mode must be token-driven, not a separate system
- All interactive states are mandatory

#INFORMATION ABOUT ME:
- Brand name: [BRAND]
- Visual personality: [MINIMAL / BOLD / LUXURY / PLAYFUL]
- Platforms: [WEB / MOBILE / BOTH]

#OUTPUT:
Design tokens (JSON) → CSS variables → Figma-ready component descriptions

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

God of Prompt

@godofprompt

Mar 11

🚨 BREAKING: Perplexity Computer just became the most dangerous tool on a public market desk.

Perplexity started out as an AI search engine but their new product Computer turns it into an AI research analyst that does real work.

Here are 8 prompts that turn Computer into a full investment analyst with real-time filings, cited sources, and zero hallucinated numbers 👇

(Save for later)

1/ LONG/SHORT EQUITY THESIS

Task: Build a complete investment thesis for [COMPANY NAME / TICKER] with a 12-18 month time horizon.
Search and retrieve:

- Latest annual and quarterly filings (10-K, 10-Q)
- Analyst consensus estimates and recent revision direction
- Last 2 earnings call transcripts
- Recent news flow (past 90 days)
- Current valuation multiples vs. 5-year historical range and sector peers

Analysis framework:

1. Identify the variant perception: what does consensus currently believe vs. what the retrieved data actually shows
2. Build normalized earnings power in base, bull, and bear case with specific drivers sourced from filings
3. Map 3 catalysts with estimated timing that could close the gap between current price and intrinsic value
3. Construct valuation range using comparable company multiples and DCF cite the source for every input
5. Define entry, add, and exit conditions

Constraints: Every estimate requires a cited source. Flag where retrieved data contradicts management guidance. Separate what is priced in from what is not. Do not synthesize a bull case from press releases.

Output: Variant perception statement (2 sentences), earnings power table across 3 scenarios with sourced assumptions, catalyst calendar with probability weights, valuation bridge, position framework.

2/ EARNINGS QUALITY FORENSICS

Task: Run a comprehensive earnings quality assessment on [COMPANY NAME / TICKER] to determine whether reported earnings accurately reflect economic reality.

Search and retrieve:

- Last 5 years of income statement, balance sheet, and cash flow statement from SEC filings
- Recent auditor commentary or restatement history
- Any accounting policy changes disclosed in filing footnotes
- Comparable earnings quality data for 3 sector peers

Analysis framework:

1. Calculate Beneish M-Score: retrieve all 8 required variables from filings and flag any above manipulation warning thresholds
2. Accrual ratio trend: compare net income to operating cash flow across 5 years, flag widening gaps with specific filing citations
3. Revenue recognition signals: DSO trend, deferred revenue movements, channel stuffing indicators in distributor commentary
4. Expense management: SG&A and R&D as a percentage of revenue over 5 years, flag unusual compressions
5. Score earnings quality 1-10 with the specific retrieved data points driving the score

Constraints: Classify every metric as clean, yellow flag, or red flag. Reference retrieved industry norms when classifying outliers. Link every flag to a specific line item in a specific filing.

Output: M-Score table with sourced variable breakdown, accrual analysis with filing citations, 5 ranked quality flags, overall quality score with rationale.2

Read 10 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!