“You can follow a spec. Now prove you can deliver without someone watching.”
You’ve shipped in a guided environment. Now you ship on a real client project — with training wheels still partially on. You’re billing at a heavy discount. The client knows you’re a developing builder working alongside Worca’s senior team. That transparency is deliberate. It means you have room to grow, but not room to fail silently.
You’re half-productive. That’s honest math. You can follow a spec and deliver working code, but you still need code review, direction on approach, and someone to catch your architectural blind spots. The goal of this level: close that gap until someone hands you a ticket and you deliver clean, reviewed, merged code without anyone worrying about it.
What You Do
- Ship features from specs — take a clearly defined ticket, implement it, write tests, open a PR. The spec is given to you; the implementation is yours.
- Participate in code review — both directions. Submit clean PRs. Review others’ PRs with increasingly useful feedback.
- Bug fixes and maintenance — triage, reproduce, fix, verify. Real client bugs, real urgency.
- Write tests — not optional. Every feature ships with tests. AI can generate the scaffolding, but you understand what’s being tested.
- Client codebase fluency — learn the patterns, conventions, and architecture of the codebase you’re working in. Don’t fight it.
- Standup and sprint participation — you’re part of a real team now. Communicate like it.
AI Skills Required
- AI-assisted implementation — break a spec into tasks, use AI to scaffold each one, refine the output
- AI-powered debugging — provide context (error, stack trace, relevant code), get suggestions, verify before applying
- Codebase navigation with AI — “explain this module,” “find where X is called,” “what does this test cover”
- AI test generation — generate test cases from specs, then review for coverage gaps
- AI-assisted code review — use AI to pre-review your own PRs before submitting. Catch the obvious stuff yourself.
- Documentation with AI — write clear PR descriptions, inline comments, and handoff notes
Self-Evaluation Checklist
- I can take a spec and deliver a working feature without asking my mentor to clarify implementation details
- My PRs pass review on the first or second round — not the fourth
- I write tests for every feature without being reminded
- I can navigate an unfamiliar part of the codebase and make a change without breaking adjacent functionality
- I estimate my own tasks within 30% accuracy
- I’ve fixed at least 5 bugs independently — reproduced, diagnosed, fixed, verified
- My code review comments are useful to the author, not just nitpicks
- I complete sprint commitments 80%+ of the time
Training Curriculum
Month 1–2: Client Codebase Onboarding
- Codebase Deep Dive — architecture walkthrough with your L4+ mentor. Understand the why behind the patterns.
- First Client Tickets — small, well-scoped features and bug fixes. Mentor reviews everything.
- Testing Discipline — learn the testing patterns in this codebase. Unit, integration, e2e — whatever they use. Match it.
- AI Onboarding Workflow — build your personal workflow for ramping on a new codebase with AI. This workflow becomes a career asset.
Month 3–4: Independent Feature Work
- Feature Ownership — take tickets from spec to merge with decreasing mentor involvement. Mentor still reviews, but you drive.
- Estimation Practice — estimate your own tickets before starting. Track actual vs. estimated. Get better.
- Code Review Depth — review 3+ PRs per week from other team members. Your comments should improve.
- Debugging Without Escalation — when something breaks, try for 30 minutes with AI before asking a human. Build the muscle.
Month 5–6: Sprint Contributor
- Full Sprint Participation — you’re carrying a real load now. Sprint commitments. Deadline pressure.
- Cross-Feature Awareness — understand how your work connects to other features. Stop building in isolation.
- Refactoring Practice — identify and improve code quality issues. Not just feature work — leave the codebase better than you found it.
- Portfolio Assembly — document features shipped, bugs fixed, review contributions. Prepare for L3 assessment.
Ranking Standard
| Metric | Threshold | How It’s Measured |
|---|---|---|
| Features shipped | 3+/month merged PRs | Git history |
| PR pass rate | First or second review round | PR history |
| Bug fixes | 5+ independently resolved | Ticket tracking |
| Test coverage | Tests on every feature PR | PR audit |
| Estimation accuracy | Within 30% | Estimate vs. actual tracking |
| Sprint completion | 80%+ of commitments | Sprint retrospectives |
Promotion to L3
Requirements
- Minimum 6 months at L2
- Pass L3 qualification assessment:
- Unfamiliar codebase challenge — given a codebase you’ve never seen (different stack than your current project), set up the environment, navigate the code, and implement a small feature in 3 hours. This is the stack-agnostic test.
- Live code review — review a PR with real issues in a codebase you don’t know. Find the bugs, the design problems, the missing tests.
- Architecture explanation — explain the architecture of your current client project to the panel. Whiteboard it. Show you understand the system, not just your corner of it.
- AI workflow audit — demonstrate your complete dev workflow. The panel measures your AI integration depth.
- Client satisfaction feedback (collected by Worca, not by you)
- Consistent sprint delivery for 3+ months
What the Panel Looks For
- Stack-agnostic potential — can they learn a new stack fast enough to be productive Day 1? This is the L3 gate.
- Independence — do they need oversight, or do they drive to completion on their own?
- Code quality — is their code clean enough that an L4 doesn’t have to rewrite it?
- AI leverage — are they using AI to be 2x productive, or just using it as a fancy autocomplete?
- Taste development — are they starting to have opinions about what good code looks like?
Mentorship at This Level
- You receive: L4+ mentor, weekly check-ins (30 min). Focus on code quality, architectural thinking, and stack breadth.
- You give: Nothing formal yet. Help onboard new L1s if asked — explain the codebase, share your AI workflows. Building the habit.
- Pair sessions: At least 2 pair sessions per month with L3+ builders on unfamiliar parts of the stack. Stretch your comfort zone.
What Unlocks at L3
- Stack-agnostic placement — any client, any codebase, Day 1 productivity
- Standard billing rate — you’re a full Worca product builder
- Architectural input (not just implementation)
- The beginning of product thinking, not just code thinking