This is a summary of a YouTube video by an experienced AI practitioner sharing battle-tested techniques for working effectively with large language models. Watch the original video
After thousands of hours building with AI for coding, writing, and planning, the creator has distilled six essential practices that solve the most common failure modes when working with LLMs. The key insight: AI will quietly drop requirements even when you're doing everything right—and these techniques help prevent that.
Here's the workflow described in this video:
- Talk, Don't Type - Record voice transcripts instead of typing prompts to preserve intent and nuance
- Work in Folders, Not Chats - Treat the project folder as the workspace, not the conversation
- Verify Every Plan - Force AI to grade its own plans against requirements to catch missing features
- Clear Context Frequently - Start fresh contexts for new features to prevent instruction decay
- Automate and Walk Away - Build traceable autonomous workflows so you can hand off work
- Build Custom Tools - Create tiny scripts and utilities to smooth workflow frictions
The Problem: When typing prompts, we self-edit, stripping out tangents, uncertainties, and "messy" thinking—but that messiness is where the real intent lives.
The Solution: Record voice "walks" where you talk through ideas unfiltered. The creator records long walks discussing projects, then transcribes them. This captures thousands of words of raw thinking that would never make it into a typed prompt.
Example from the video: The creator showed a rambling, stammered transcript full of partial thoughts that became the foundation for the entire video you're watching.
Key Insight: You want to dump as much as possible—that's the "raw marble" you'll carve down later. The treasure is in what you capture, not what you filter out.
The Problem: When you do all your thinking in chat, you end up with "vibes"—a long thread with half-decisions and no reusable artifacts. Chat is ephemeral.
The Solution: Create a project folder structure and treat it as the workspace. Use subdirectories like:
content-in/- Where you put input materialscontent-out/- Where AI writes outputsCLAUDE.md- Instructions for AI about folder structure
The Workflow:
- Create a folder and basic structure
- Drop your transcribed walks into content-in
- Ask AI to read and analyze them
- Have AI write questions to files
- Record answers and drop them in as new files
- Iterate, building up a graph of documents
Key Insight: Files are durable. This makes work reusable, handable to future sessions, and creates a graph of ideas rather than a single conversation thread. As the creator emphasizes: "The folder is the workspace. Quit letting your chat experience be the workspace."
The Problem: The creator ran controlled experiments and found that around 40% of requirements were silently dropped by AI during planning—not edge cases, but core features.
The Solution: After AI generates a plan, ask it to verify itself against the original requirements. Use a prompt like:
"Evaluate this plan against the original PRD. For each major requirement, mark it as covered/partial/missing. Then create a coverage report and replan if needed."
Results from the video:
- Initial plan looked complete but was missing 22% of requirements
- Verification caught critical omissions like "click outside to dismiss" and "tab navigation"
- After one verification pass, coverage typically reaches 95%+
Key Insight: This works because it forces a second pass with a different posture—coverage, not creativity. It feels redundant, but the empirical results are undeniable.
The Problem: The longer a conversation gets, the weaker your initial instructions become. You start a session saying "run tests before you tell me you're done," and two hours later AI confidently says it's done without running anything.
The Solution:
- Start a fresh context for each new feature or unit of work
- If something needs to survive across contexts, write it to a document
- Don't hope the model remembers—make memory external
Key Insight: Context decay is real. Instructions injected at the beginning (like CLAUDE.md files) fade as the conversation grows. Clearing context keeps instructions sharp and work focused.
The Problem: Most people become AI babysitters—sitting there approving things, switching tabs, context-switching all day. It's exhausting.
The Solution: The creator built a system called "do work" that enables autonomous, traceable task completion:
- Give AI a complex request (voice recording, written description, screenshot)
- AI breaks it into independent, verifiable requirements
- Each requirement gets its own file with full context
- AI verifies coverage against original request (using technique #3)
- Requirements are stored as artifacts in the folder structure
The do-work Execution Process:
- AI picks the first unclaimed requirement
- Moves it to "working" status
- Completes it in a fresh sub-context (using technique #4)
- Creates a detailed git commit with traceability
- Returns to main loop and repeats
- Every commit includes complete context about what was asked for
- All supporting files are checked in
- AI can crawl git history to find when requirements were added or regressed
- The system is "self-solving" because it can trace changes
Key Insight: "Autonomy without traceability is chaos." If you can't answer "what changed and why," you'll be scared to let AI run unsupervised. Traceability buys confidence, and confidence buys time.
The Problem: Off-the-shelf tools are built for everyone, which means they're built perfectly for no one. They don't fit your specific workflow.
The Solution: When something irritates you, build the fix:
- A slash command
- A tiny script
- A custom skill
- A hook or automation
Example from the video: The completion sound that plays when AI finishes work—not impressive software, just a missing ergonomic the creator wanted.
Key Insight: With AI, the bar for building custom tools is "nearly on the floor." Every friction becomes an opportunity to improve the system. The workflow itself is a product that gets better through iteration.
- AI's failure mode is silent - It will drop core requirements without warning, even when you're doing everything right
- Voice captures intent better than typing - Unfiltered recordings preserve the nuance and context that typed prompts lose
- Files > Chat - Treat the folder as your workspace; make memory external and durable
- Always verify plans - A single verification prompt catches ~20-40% of missed requirements
- Context decays over time - Fresh contexts for new features keep instructions sharp
- Traceability enables autonomy - You can only walk away if you can trace what changed and why
- Build for your workflow - Custom micro-tools compound over time to create a personalized system
- Try one technique first - Don't adopt all six at once; pick the one that addresses your biggest pain point
- Record your next brainstorm - Use voice recording instead of typing for your next project kickoff
- Set up a project folder structure - Create content-in and content-out directories for your next AI collaboration
- Add verification to your planning - After AI creates a plan, ask it to grade itself against requirements
- Start clearing context more frequently - Begin fresh conversations for each major feature or unit of work
- Identify one workflow friction - Find one irritating manual step and build a tiny tool to automate it
Meta Point: These aren't just "tips"—they're the result of thousands of hours of experimentation. The creator built, tested, threw away, and rebuilt these practices until they survived real-world use. Your workflow is a product that improves through iteration, just like your code.