Show Notes
This video breaks down Parker Rex’s daily Cursor-driven workflow for building, testing, and shipping with high velocity. It covers setup, memory strategies, task orchestration, and practical patterns you can clone in TypeScript projects to 10x output while reducing errors.
Cursor setup and core rules
- Start with solid rules in Cursor and prefer official ones when available.
- Quick backend for demos: use Superbase for speed and ease (vs rolling your own Postgres).
- Quick rule setup tip:
- Use pnpm dlx shaden@latest to add editor rules to Cursor.json.
- This adds five essential rules: create DB functions, create migrations, create RLS policies, Postgres SQL style guide, and edge functions.
- Expect to extend with other rules (e.g., taskmaster, llm.txt) as you grow.
- Keep your rules in a central place and reuse them across projects.
Context sources and context management
- llm.txt and llms.org: use these to provide structured context to LLMs; they help models read large references quickly.
- llm data sets: leverage directories and source graphs to keep prompts and data manageable.
- repo pack / repo mix: compress project context into an LLM-friendly markdown file for offline or constrained environments.
- CI/CD prompts and tests: add tests and guardrails early to catch regressions as you scale.
Code patterns and integration basics
- Break integrations into small, TS-specific modules (e.g., Google Calendar, Contacts).
- Each module should have a minimal surface area and clear typings; this makes it easy for humans and LLMs to debug.
- Prefer a singleton/auth pattern for API access to avoid repetition.
Example structure (conceptual):
- integrations/google-calendar.ts
- integrations/contacts.ts
- lib/db.ts (singleton for DB access)
Prompt tooling and workflow primitives
- Doc Rock (doc rocker): a one-pager doc generator that helps you capture usage and API surface for a given integration or flow.
- MIMO: a notebook-on-steroids for iterative prompt testing; great for testing prompts across models quickly.
- Use Whisper Flow for voice-to-text capture when drafting PRDs or specs—transcriptions with live corrections speed up “thinking out loud” capture.
- Prompt chaining and agentic workflows:
- Agent vs. agentic workflow: an agent operates autonomously; an agentic workflow has humans in the loop and a structured set of tools.
- For speed, Parker uses task-driven agentic workflows that mimic real-world product/process flows.
Actionable drafting flow (high-level)
- Step 1: Draft PRD in your own voice (Whisper Flow helps here).
- Step 2: Pull in code snippets and relative paths from the repo (doc rock or code docs).
- Step 3: Feed the draft into a prompt to generate a first pass.
- Step 4: Use an RCA-like prompt chain (see “common patterns”) to surface gaps and questions.
- Step 5: Run step two as a separate prompt to finalize the PRD with dependencies and concrete steps.
- Step 6: Use Taskmaster to decompose the PRD into actionable tasks with clear dependencies.
Sample prompt flow outline (conceptual):
- Draft PRD (human voice + code references)
- PRD → Taskmaster (10 tasks, with dependencies; break large tasks into subtasks if needed)
- If gaps exist, run a research pass (Perplexity/sonar) to fill in missing details
- Produce a final PRD draft (via purity.txt parsed by Claude)
Code snippet (illustrative)
- A skeleton PRD+tasks payload (conceptual):
json
{
"prd": "Phantom Wallet landing page with multi-step onboarding",
"tasks": [
{ "title": "Set up TS module scaffolding", "dependencies": [] },
{ "title": "Create API surface for wallet interactions", "dependencies": ["Set up TS module scaffolding"] },
{ "title": "Integrate payment flow", "dependencies": ["Create API surface for wallet interactions"] }
],
"notes": "Use voice-driven PRD drafting; feed into Taskmaster for structured outputs."
}
Taskmaster and memory bank: driving structured outputs
- Taskmaster is the backbone for breaking PRDs into bite-sized, well-structured tasks.
- Default 10 tasks, with the option to break large items into subtasks.
- Structured outputs: title, status, dependencies, details.
- Can pull in external research (sonar by perplexity) when needed.
- In practice, it’s a high-velocity “go-to” for product/project decomposition.
- Memory Bank (Klein’s approach):
- A flowchart-like context: project brief, product context, system patterns, tech context, active context, progress.
- Ensures every request checks for required files and context, reducing drift.
- Extremely helpful when onboarding to a new codebase; keeps architecture and decisions consistent.
Practical takeaway
- Use Taskmaster to generate the initial task graph. Then use a memory-bank ramp to ensure you’re aligned with project context and patterns before coding.
Model selection and practical cautions
- Model strategy:
- 2.5 Pro is Parker’s go-to for many prompt-driven tasks (speed and reliability).
- Google’s model is mentioned with performance numbers as a comparison (roughly mid-range accuracy and cost concerns).
- Claude is used downstream for parsing and final drafting in some flows (purity.txt → Claude).
- Guardrails and cost:
- Taskmaster provides strong guardrails around outputs.
- Keep models aligned with your workflow; balance speed, cost, and accuracy.
- Testing and tooling:
- Don’t skip tests; use strict linting/formats and CI/CD hooks.
- Prefer stable frameworks with larger ecosystems for better model coverage and docs.
Codebase patterns and best practices
- Small, modular files beat large monoliths when it comes to LLM contexts.
- Use API wrappers with clear, typed interfaces; minimize repeated logic.
- Singleton patterns for auth and critical shared resources to avoid duplication.
- Doc Rock and code docs: keep usage examples and relative paths up-to-date for quick re-use.
- Framework and library choices:
- Favor well-supported frameworks with large communities to improve model familiarity.
- For front-end/back-end, TS docs-friendly patterns help models understand usage quickly.
Common problems and quick fixes
- If Cursor performance degrades:
- Delete chats and start fresh periodically.
- Clear cache (RMF on the Cursor cache) and reset the shadow workspace.
- If issues persist, reinstall via Homebrew and use an app cleaner to purge artifacts.
- If prompts go off-track:
- Re-index data sources; ensure docs are in llm.txt or llm data sets.
- Shorter, modular prompts tend to be more robust than bulky ones.
- Environment/IDE tips:
- Turn on beta features and ensure indexing is on; check prompt/documentation alignment.
- Use consistent voice in PRDs to reduce cognitive load for the model and yourself.
- Terminal and workflow speed:
- Use Warp or a fast terminal; map frequent actions to zsh shortcuts.
- Leverage macros and aliases (e.g., p, rundev, open project) to reduce friction.
Quick takeaways you can action today
- Set up a solid Cursor baseline with official rules and a Superbase-backed local/remote DB.
- Add LLM context via llm.txt and llms.org to help models read large references.
- Implement Taskmaster for PRD-to-tasks with clear dependencies; link to a memory bank for project context.
- Draft PRDs in your own voice (use Whisper Flow) and refine with AI prompts; surface gaps with RCA-style prompts.
- Build small, modular integration files with clear surface APIs and a singleton auth module.
- Use CI/CD and linting/tests early to prevent drift as you scale.
- Join the community channels (daily updates, Vibe with AI) to see real-world workflows and free prompts.
Links
- Cursor (official setup and rules)
- Supabase (quick backend)
- llms.txt (context sharing for LLMs)
- Repomix (offline context packaging)
- Task Master (structured task decomposition)
- Cline Memory Bank (context-aware workflow)
- Claude (for parsing purity outputs)
- Perplexity sonar (research augmentation)
- Wispr Flow (voice-to-text drafting)
- Warp (fast terminal)
- pnpm (fast, disk space efficient package manager)
If you want to see this approach in action, check out Parker Rex Daily and the Vibe with AI community for hands-on examples and open-source project demos.