The Heuristics Behind Intuition
An invisible framework is not code. It is a set of habits for decomposing problems, making decisions, and controlling complexity. The ten heuristics below are prompts for judgment, not universal rules.
Simplest Viable Solution
Ask: "What is the simplest solution that meets the verified requirements?" Prefer fewer moving parts when reliability, security, operability, and likely change remain acceptable.
Separate Concerns
UI, logic, and data should have clear boundaries. When a component handles rendering, state management, API calls, and validation, it becomes impossible to modify without breaking something. Every function should answer the question "what is my one job?" cleanly.
Optimize for Change
Don't design for perfection — design so you can change things later without pain. The future is unpredictable. The architecture that's easy to modify beats the architecture that's theoretically optimal but rigid. Ask: "If requirements change next month, how painful is this to adapt?"
Reduce Unknowns Early
Identify the biggest risk first and tackle it first. "What am I least sure about?" That's what you prototype first, research first, test first. Everything else can wait. Unknowns that persist become surprises that derail timelines.
Think in Feedback Loops
Seek feedback early enough to change direction, but make sure it represents the real requirement or risk. Ask whether a workflow change improves the speed, relevance, or reliability of feedback.
Make Constraints Explicit
Undefined constraints lead to undefined results. Before designing anything, define your constraints: performance targets, team size, budget, timeline, technical limitations. Constraints aren't restrictions — they're the boundaries that make good design possible.
Minimize Future Complexity
When choosing between approaches, compare likely maintenance costs over a useful planning horizon. State the assumptions: future requirements cannot be predicted with certainty.
Use AI as One Reflective Mirror
Ask AI to challenge assumptions and suggest counterexamples, then compare its response with data, documentation, and people who bring different experience. AI can repeat the same blind spots present in its context.
Think in Layers of Abstraction
Fluently move between levels: vision → architecture → components → functions → implementation details. The right answer depends on which level you're thinking at. A function-level optimization is irrelevant if the architecture-level design is wrong.
Cognitive Economy
Use automation for suitable repetitive work, but keep review proportional to risk. Boilerplate, documentation, and generated tests can still contain consequential errors.
When the Framework Becomes Invisible
With practice, these questions can become routine. Periodically make them explicit again so assumptions and outdated habits remain open to review.
Internalized habits are useful only while they continue to produce sound results. Keep the ability to explain, test, and revise them.
The invisible framework isn't something you learn once. It's something you practice until it disappears into intuition. Every chapter in this book contributes one piece. The framework emerges when you've practiced enough that the pieces connect automatically.
The Journey Forward
You have reached the end of the manual. Apply one technique in a real project, record the outcome, and revise the workflow when the evidence calls for it.
The developers who thrive in the AI era won't be the ones who memorize the most prompts. They'll be the ones who think clearly, decide quickly, review critically, and improve continuously.
That's you, if you practice what's in these pages.
Key Takeaways — The Complete Manual
- Start with clear, structured prompts — Goal, Context, Technology, Constraints, Output Format
- Use AI as a team: junior dev, senior reviewer, architect, debugger — switch roles fluidly
- Review consequential design choices before implementation
- Use reviewable iterations and scale rigor to risk
- Review everything AI generates — you own the code, including its flaws
- Test continuously — AI generates tests in seconds, removing the last excuse
- Build reusable prompt architectures — templates and pipelines, not ad-hoc prompts
- Think with AI, not just code with AI — cognitive workflows produce better decisions
- Practice the Meta Loop — continuously improve your workflow, not just your output
- Trust the invisible framework — the heuristics become intuition through practice
Related Guides
You've finished the manual. The concepts stick when you apply them. Here are the best places to go from here:
Weekend Build: Planning & Architecture
Put the manual into practice. Build a real full-stack app across five structured parts — from architecture to deployment.
When AI Gets It Wrong: A Field Guide
What to do when AI confabulates, loops, or produces confidently wrong output. The practical failure-mode guide.
AI Prompt Library
53 copy-paste prompts across 10 categories. Searchable and filterable — your reusable prompt toolkit.
Testing with AI
Unit tests, integration tests, TDD, and AI evals. The guide for making sure your AI-assisted code actually works.