Time to level up: ~1 week
User: "Write a function to validate emails"
AI: *writes generic function*
User: "Make it TypeScript"
AI: *rewrites function*
User: "Use our naming conventions"
AI: "What are your naming conventions?"
User: "camelCase"
AI: *rewrites again*
User: "Add error handling"
AI: *rewrites again*
...12 more turns...
User: "I'm building a user registration feature in TypeScript.
We use Zod for validation and follow camelCase naming.
I need email validation that:
- Checks RFC 5322 format
- Blocks disposable domains
- Returns structured errors
Can you implement this?"
AI: *writes complete function in one shot*
User: "Great. Now add unit tests using Jest"
AI: *writes tests, knows context already*
User: "The regex is catching valid emails. Why?"
AI: *explains and fixes*
None required. This transition is purely behavior change.
You don't need to learn any new skills or tools. You just need to change how you interact with AI.
Before your next AI interaction, write down:
Include all 5 in your first message. Every time.
Example:
Instead of:
"Write a function to parse dates"
Write:
"I'm adding date parsing to our event scheduling module.
We use TypeScript with date-fns library. The dates come from
an external API in ISO 8601 format but sometimes malformed.
I need a function that:
- Parses valid ISO dates
- Returns null for invalid dates (don't throw)
- Handles timezone conversion to UTC
This will be used in EventService.ts"
For your next task, complete the entire thing in ONE conversation.
Rules:
Track your turns: Count how many messages you send. Goal: under 10.
Example chain:
Turn 1: [Context + initial request]
Turn 2: "Now add error handling for edge case X"
Turn 3: "Good. Also add logging using our logger"
Turn 4: "Now integrate this with UserService"
Turn 5: "Tests are failing—here's the error: [paste error]"
Turn 6: "Perfect, thanks"
When AI gives you code, ask at least one "why" question.
Why this matters: You'll learn more, catch issues earlier, and build understanding that compounds over time.
Example:
User: "Write a retry function for API calls"
AI: *writes function with exponential backoff*
User: "Why exponential backoff instead of fixed delays?"
AI: "Exponential backoff prevents thundering herd..."
User: "What if the API has rate limiting headers?"
AI: "Good point, we should respect Retry-After..."
You've reached L2 when:
| Metric | L1 | L2 Target |
|---|---|---|
| Average turns per task | 15+ | 5-10 |
| Context in first message | Rarely | Always |
| New conversation per thought | Yes | No |
| Asks "why" questions | Never | Sometimes |
The clearest sign: Your conversations average 5-10 turns, not 15+.
❌ "This code isn't working" (what code? what error? what expected behavior?) ✅ "The validateEmail function in UserService.ts is returning false for valid emails like 'user+tag@domain.com'. Error: [paste]. Expected: should return true for valid plus-addressing"
❌ [New conversation] "Now I need to add tests" ✅ [Same conversation] "Now add tests for the edge cases we discussed"
❌ "Write a function" ... [accepts] ... [new conversation] "Write tests" ✅ "Write a function" ... "Now add tests" ... "Now integrate with the service"
I'm working on [WHAT: feature/fix/investigation].
Context: [WHERE: file/module/system].
Tech stack: [WITH: language, frameworks, libraries].
Constraints: [LIMITS: time, compatibility, style rules].
Success looks like: [CRITERIA: what "done" means].
[YOUR SPECIFIC REQUEST]
Once you consistently:
You're ready for L2-to-L3: Conversationalist to Delegator.
The next level introduces skills—structured workflows that make you even more efficient.
Remember: L1 → L2 is the easiest transition. It requires no new tools, just mindset change. You can do this in a week.