AI Workflow · Module 2
Green Light / Red Light
"The skill isn't in using AI. It's in knowing when not to."
Six months into using AI daily, a developer sat down with a blank file, no AI assistant running. A task that should have taken 20 minutes took two hours. The algorithms that used to come naturally felt distant. The debugging intuition that took years to build had dulled.
This is the dependency trap. And it doesn't announce itself.
The answer isn't to stop using AI — that would be like stopping GPS to maintain your map-reading skills (useful) but walking everywhere instead of driving (absurd). The answer is to use AI strategically. To have a clear, principled system for what you delegate and what you own. That's the Green Light / Red Light framework.
The Mental Model: Senior Dev and Junior AI
Before the framework, internalize the relationship.
- Architectural vision
- Business context
- Security judgment
- Strategic trade-offs
- Final responsibility
- Superhuman execution speed
- Encyclopedic syntax recall
- Pattern-based generation
- Zero real-world experience
- No business context
A master chef and a prep cook. The chef designs the menu and tastes the result. The prep cook chops ingredients at speed. Neither role is dispensable. But only one is the chef.
The junior developer analogy is precise: you would never let a junior merge payment-processing code without a thorough review. You wouldn't let them design the database schema alone. But you'd absolutely let them generate boilerplate, write documentation, or convert one format to another. That's the instinct to formalize.
The Framework: Two Categories, One Clear Rule
The classification rule is simple: if a bug in this code could cause a security incident, a data loss event, or a production outage — it's Red.
A Real Feature: Both Colors at Once
Most real work contains both Green and Red tasks. The skill is separating them.
Feature: Build a product search endpoint.
fuzzySearch(query, filters) method based on the algorithm I just designed.SearchFilters and SearchResult.ProductSearchService covering the edge cases I specified.GET /api/search endpoint.You made 2 Red decisions. Then you delegated 4 Green tasks. You are not avoiding AI — you are using it on the 80% of work where it excels, while protecting the 20% that requires your judgment.
The Skill Atrophy Problem
Here's what the research shows: after extended periods of complete AI delegation, developers report meaningful degradation in:
- Algorithmic reasoning ("I used to know this instinctively")
- Debugging without a prompt ("I don't know where to start without paste + ask")
- System-level thinking ("I haven't designed a schema from scratch in months")
This isn't theoretical. It's the same as any skill: unused muscles weaken. And in software development, your problem-solving muscle is your career asset.
Three practices that prevent it:
The 70/30 Rule: A Sustainable Ratio
The most effective long-term framework is simple:
The 30% manual isn't the boring 30%. It's the highest-value 30% — the decisions that determine whether the system is maintainable, scalable, and secure. AI helps you move faster everywhere else so you can give this 30% your full attention.
The developers who master this ratio are the ones who, twelve months from now, are faster than everyone else and sharper than they were before they started.
Next: The Specification Framework → — How to write prompts that generate production-ready code on the first try, eliminating the back-and-forth that wastes most developers' time.