purpose: Core 80-20 principles of Tactical Agentic Coding - three tactics that deliver 80% of value type: foundational-reference course: Tactical Agentic Coding category: core-principles difficulty: beginner-intermediate dependencies: lesson-01, lesson-02, lesson-03 last-updated: 2025-09-30 The Pareto Principle states that 80% of results come from 20% of efforts. In Tactical Agentic Coding, three core tactics deliver 80% of the value: Stop Coding, Adopt Your Agent's Perspective, and Template Your Engineering. This guide explains why these three fundamentals matter most and how to master them. # THE 80-20 OF AGENTIC CODING **Three Tactics That Deliver 80% of Impact** --- ## THE PARETO PRINCIPLE IN AGENTIC CODING ### Understanding 80-20 The Pareto Principle (80-20 rule) states that roughly 80% of effects come from 20% of causes. In business, 80% of sales come from 20% of customers. In software, 80% of bugs come from 20% of code. In agentic coding, 80% of leverage comes from 3 core tactics. ### Why This Matters **WITHOUT 80-20 FOCUS:** - Learn all 7+ tactics (overwhelming) - Try to master everything at once (slow progress) - Equal time to high and low-impact activities (inefficient) - Delayed results (months to see value) **WITH 80-20 FOCUS:** - Master 3 core tactics first (achievable) - See immediate results (days to impact) - Build foundation for advanced tactics (enables future growth) - Compound effects start immediately (exponential returns) ### The Distribution **TAC TACTICS BY IMPACT:** ``` ┌─────────────────────────────────────────┐ │ Tactic #1: Stop Coding 35% │ ███████████████ │ Tactic #2: Agent's Perspective 25% │ ███████████ │ Tactic #3: Template Engineering 20% │ █████████ ├─────────────────────────────────────────┤ │ CORE THREE TOTAL 80% │ ← Focus here first ├─────────────────────────────────────────┤ │ Tactic #4: AFK Agents 8% │ ████ │ Tactic #5: Feedback Loops 7% │ ███ │ Tactic #6: Review/Docs 3% │ ██ │ Tactic #7: Zero Touch 2% │ █ ├─────────────────────────────────────────┤ │ ADVANCED FOUR TOTAL 20% │ ← Learn later └─────────────────────────────────────────┘ ``` **INTERPRETATION:** - Master tactics 1-3 → Get 80% of possible value - Add tactics 4-7 → Get remaining 20% - Start with fundamentals, build to advanced --- ## THE THREE CORE TACTICS ### Overview 35% of total value Your hands and mind are no longer the best tool for writing code Frees you from typer role to orchestrator role 25% of total value Always think from your agent's perspective - can it see what it needs? Agents execute successfully first time instead of failing 20% of total value Solve problem classes, not individual problems Exponential scaling through reuse Together these three create multiplicative effects: - Stop Coding × Agent Perspective × Templates = 100-1000x leverage - Each amplifies the others - Foundation for all advanced tactics --- ## TACTIC #1: STOP CODING (35% Impact) ### The Fundamental Mindset Shift Coder Lines of code written per day Keyboard and IDE Linear with typing speed (100-300 lines/day) Your fingers Engineering Orchestrator Systems delivered per day Prompts and agents Exponential with leverage (equivalent of 10,000+ lines/day) Your thinking (prompts quality) ### Why Stop Coding? - Agent typing speed: 1000+ lines/minute - Human typing speed: 50-100 lines/hour (with thinking) - Agent advantage: 600-20,000x faster at raw coding - Planning a feature: Requires creativity, context, judgment - Typing the feature: Mechanical, deterministic, automatable - Your brain's unique value: Planning - Agent's unique value: Execution - Switching between planning and coding: 15-20 min lost per switch - Typical day: 10-20 switches = 150-400 minutes lost - Staying in planning mode: Zero switching cost - Agent in execution mode: Zero switching cost - Human coding: Quality varies with fatigue, mood, distractions - Agent coding: Consistent quality, follows patterns exactly - Human at hour 1: 90% quality - Human at hour 8: 60% quality - Agent at hour 1: 90% quality - Agent at hour 24: 90% quality ### What "Stop Coding" Means - Never read code (you MUST read code) - Never review code (you MUST review) - Never understand implementation (you MUST understand) - Give up technical skills (you MUST maintain expertise) - Stop TYPING code as primary activity - Stop MANUALLY WRITING implementations - Stop SPENDING HOURS in text editor - Stop BEING BOTTLENECKED by fingers ### How to Implement Awareness - Track how much time you spend typing code vs planning - Notice when you're typing something agent could do - Start catching yourself before typing - Ask: "Could an agent do this?" Awareness of how much time is spent typing Experimentation - Try having agent implement simple tasks - Compare time: your typing vs agent execution - Measure quality: your code vs agent code - Build confidence in agent capabilities Agent successfully handles 3-5 simple tasks Delegation - Default to agent for all new code - Reserve typing for quick fixes only (<5 lines) - Spend typing time on planning instead - Measure impact on daily output 80% of code written by agent Orchestration - Focus entirely on planning and review - Multi-task agents for parallel work - Measure output: features completed, not lines typed - Celebrate orchestration wins 100% of code written by agent, output doubled ### Measuring Success Lines written by agent / Total lines 95%+ written by agent Planning time / Typing time 4:1 ratio (80% planning, 20% typing) Features completed per week 2-5x increase from baseline Ability to maintain strategic focus Can work on 3-5 features concurrently --- ## TACTIC #2: ADOPT YOUR AGENT'S PERSPECTIVE (25% Impact) ### The Core Question "Can my agent see everything it needs to complete this task successfully?" ### Understanding Agent Blindness Agent starts every session with zero context Can't remember previous conversations or decisions Provide all context in prompt or accessible files Agent cannot assume anything about your codebase Doesn't know your patterns, conventions, preferences Make patterns explicit, reference example files Agent won't proactively search for missing information Will fail if required context not provided Explicitly list what files to read, what to analyze Agent cannot read your mind or infer unstated requirements Will implement exactly what you say, not what you mean Be explicit about all requirements and expectations ### The Agent Perspective Checklist Can agent see all relevant files? "Update the user component" "Update src/components/User/UserProfile.tsx following pattern in src/components/Product/ProductCard.tsx" Does agent know what patterns to follow? "Add error handling" "Add error handling using the try-catch pattern in src/utils/errorHandler.ts, wrap API calls and log errors with logger.error()" Can agent verify its work succeeded? "Make sure it works" "Verify by running: npm run test -- user.test.ts (all pass), npm run type-check (no errors), manual test: curl POST /api/users with valid data returns 201" Does agent know what "done" looks like? "Improve the performance" "Reduce response time from current 450ms to under 200ms, verify with npm run test:perf -- /api/users" Does agent know what NOT to change? "Refactor the authentication" "Refactor authentication logic but DO NOT change: public API contracts, existing test behavior, or files outside src/auth/" Does agent have access to necessary tools? "Deploy to production" "Deploy to production using: npm run build, then npm run deploy:prod (requires AWS credentials in .env.production)" ### Common Agent Perspective Failures Agent asks clarifying questions or makes wrong assumptions Prompt assumes agent knows your codebase Bad: "Add pagination" Agent: "What pagination style? Offset or cursor? What library?" Good: "Add offset-based pagination using our existing PaginationHelper in src/utils/pagination.ts (see UserList.tsx lines 34-56 for example)" Agent creates code that doesn't match project style Agent didn't see example of preferred pattern Bad: "Create a React component" Agent creates class component (outdated pattern) Good: "Create React functional component following pattern in src/components/Button/Button.tsx (hooks, TypeScript, CSS modules)" Agent says "done" but work is incomplete No clear success criteria specified Bad: "Fix the bug" Agent changes code, says done, bug still exists Good: "Fix bug where users can't login. Success = curl POST /login with valid credentials returns 200 and JWT token, npm run test -- auth.test.ts all pass" Agent changes more than intended No boundaries specified Bad: "Improve error handling" Agent refactors entire codebase Good: "Improve error handling ONLY in src/api/routes/users.ts, add try-catch to all route handlers, return proper HTTP status codes, don't modify other files" ### Building Agent Perspective as Habit Before every prompt, pause "What does the agent need to know?" 15 seconds List required context "What files must it read? What patterns must it follow?" 30 seconds Define success clearly "How will agent know it succeeded?" 30 seconds Specify boundaries "What must NOT change?" 15 seconds 90 seconds of thinking saves 30-60 minutes of failed attempts ROI: 20-40x ### Measuring Success Tasks completed successfully without iteration / Total tasks 20-40% without agent perspective 80%+ with agent perspective Number of times agent asks for clarification 5-10 per task <1 per task Attempts needed to complete task 3-5 iterations 1-2 iterations Tasks that stay within intended scope 50-60% 95%+ --- ## TACTIC #3: TEMPLATE YOUR ENGINEERING (20% Impact) ### The Scaling Breakthrough Every similar task requires planning from scratch: - Add API endpoint #1: 30 min planning - Add API endpoint #2: 30 min planning - Add API endpoint #3: 30 min planning ... - Add API endpoint #100: 30 min planning Total: 3,000 minutes (50 hours) on planning alone Create template once, use infinitely: - Create API endpoint template: 120 min - Use template for endpoint #1: 30 sec - Use template for endpoint #2: 30 sec ... - Use template for endpoint #100: 30 sec Total: 170 minutes (2.8 hours) Savings: 47.2 hours (94% reduction) ### What Makes Templates 20% of Total Impact 40% of template value One template used 100+ times = 100x leverage Each use takes seconds, saves 20-60 minutes Compounds over time as template improves 25% of template value Every use follows best practices exactly No variation based on engineer skill or fatigue Team outputs uniform quality Reduces technical debt 20% of template value Expert knowledge encoded once Junior engineers access senior expertise Onboarding time reduced 10x Institutional knowledge preserved 15% of template value Templates enable agent autonomy Comprehensive specs = no human in loop Agents execute while you sleep Truly scalable engineering ### The Template Mindset "I need to add a new API endpoint" [Spends 30 minutes planning specific endpoint] [Implements] [Next time: repeats entire process] "I need to add a new API endpoint" [Recognizes this is a problem CLASS, not instance] [Uses template that solves all API endpoints] [30 seconds later: comprehensive plan generated] [Agent executes autonomously] ### Core Template Strategy Start with Your Top 3 80% of your work falls into ~10 categories, top 3 = 50% 1. Track your work for 1 week 2. Identify top 3 repetitive tasks 3. Create template for each 4. Use for 1 month 5. Measure time savings Quality Over Quantity One excellent template worth more than 10 mediocre ones Invest 2-4 hours creating comprehensive template: - Complete context gathering - All edge cases - Comprehensive validation - Clear success criteria Result: 95%+ success rate Iterate Based on Failures Templates improve with use After each use: - Did it work first time? - What was missing? - What could be clearer? - Update template Result: Compound improvement over time Share with Team Team reuse = exponential impact Personal use: 10x leverage Team use: 10x × team_size leverage Result: 10 person team = 100x leverage ### Template ROI Calculation **Task:** Add CRUD API endpoint **Frequency:** 20 times per year **Manual time per instance:** 2 hours **Template creation time:** 4 hours **Template use time:** 2 minutes **WITHOUT TEMPLATE:** Year 1: 20 endpoints × 2 hours = 40 hours Year 2: 20 endpoints × 2 hours = 40 hours Year 3: 20 endpoints × 2 hours = 40 hours Total: 120 hours over 3 years **WITH TEMPLATE:** Template creation: 4 hours (Year 1) Year 1: 20 × 2 min = 40 min Year 2: 20 × 2 min = 40 min Year 3: 20 × 2 min = 40 min Total: 6 hours over 3 years **SAVINGS: 114 hours (95% reduction)** **TEAM SCALE (10 engineers):** Without: 1,200 hours With: 4 + 10 hours = 14 hours Savings: 1,186 hours (99% reduction) Equivalent: 30 weeks of engineer time Break-even at: 4 hours ÷ (2 hours - 2 min) ≈ 2 uses After 2 uses: Already saving time After 20 uses: 36 hours saved After 100 uses: 194 hours saved ROI increases with every use ### Measuring Success Percentage of work covered by templates 80% of common tasks Categorize all work, count templates available Percentage of eligible tasks using templates 90%+ adoption Log when template used vs manual approach Template uses that succeed without iteration 80%+ Track validation passes on first attempt Time saved per template use 20+ minutes per use Compare template time vs manual time --- ## WHY THESE THREE MATTER MOST ### The Multiplicative Effect **Tactic #1 alone:** 10x output (agent vs human typing speed) **Tactic #2 alone:** 3x success rate (better prompts) **Tactic #3 alone:** 10x efficiency (reusable templates) **All Three Together:** 10 × 3 × 10 = 300x **HOW:** - Stop Coding: Agent types code 10x faster than you - Agent Perspective: Your prompts succeed 3x more often - Templates: Your prompts are reused 10x **RESULT:** One engineer with these three tactics = output of 300 traditional engineers **NOT HYPERBOLE:** Measured results show 100-1000x leverage is achievable ### The Foundation for Advanced Tactics - Stop Coding: Must trust agent to work autonomously - Agent Perspective: Must provide complete context - Templates: Agents need comprehensive plans All three fundamentals - Stop Coding: Agent must run validation - Agent Perspective: Validation must be specified - Templates: Validation encoded in template All three fundamentals - Stop Coding: Agent generates docs - Agent Perspective: Agent knows what to document - Templates: Documentation requirements standardized All three fundamentals All of the above + complete automation All six previous tactics ### The Compounding Effect **Week 1:** Learn tactics, initial attempts - Output: 1.2x baseline **Week 2:** Build confidence, create first templates - Output: 2x baseline **Week 4:** Templates mature, agent perspective habitual - Output: 5x baseline **Week 8:** Template library growing, team adoption - Output: 15x baseline **Week 12:** Advanced tactics unlocked, autonomous execution - Output: 50x baseline **Week 24:** Full agentic workflow, zero touch for many tasks - Output: 200x baseline **COMPOUND GROWTH, NOT LINEAR** --- ## PARETO PRINCIPLE FOR EACH TACTIC ### 80-20 of Stop Coding **80% OF VALUE FROM 20% OF ACTIONS:** **Don't type implementations (35% of tactic value)** - Let agent write all new code - Reserve typing for quick fixes only **Spend typing time on planning instead (25%)** - Better prompts = better results - Planning is your unique value **Measure output in features, not lines (20%)** - Change success metric - Celebrate orchestration wins **Everything else (20%)** - Learning advanced agent features - Optimizing IDE for prompting - Reading about AI coding ### 80-20 of Agent Perspective **80% OF VALUE FROM 20% OF ACTIONS:** **Provide relevant context (40% of tactic value)** - Reference example files - Specify patterns to follow **Define clear success criteria (30%)** - Exact validation commands - Measurable outcomes **Specify constraints (10%)** - What must NOT change - Scope boundaries **Everything else (20%)** - Advanced prompting techniques - Optimization - Edge cases ### 80-20 of Template Engineering **80% OF VALUE FROM 20% OF ACTIONS:** **Create templates for top 3 tasks (50% of tactic value)** - Focus on highest frequency work - Quality over quantity **Include validation in templates (25%)** - Specific commands - Success criteria **Share templates with team (5%)** - Multiply impact - Get feedback **Everything else (20%)** - Advanced meta-prompts - Template optimization - Documentation --- ## IMPLEMENTATION ROADMAP ### Week-by-Week Plan Tactic #1: Stop Coding - Awareness of current typing vs planning ratio - First successful agent implementation - Measure baseline output - Day 1-2: Track time typing vs planning - Day 3-4: Try agent on 3 simple tasks - Day 5-7: Agent handles all new implementations - Agent writes 50%+ of code - Complete at least 3 tasks via agent - Measured baseline metrics Tactic #2: Agent Perspective - Prompts include necessary context - First-time success rate improving - Fewer iterations needed - Day 1-2: Practice context checklist - Day 3-4: Add success criteria to all prompts - Day 5-7: Reference example files in prompts - 50%+ first-time success rate - Average <3 iterations per task - Agent asks <2 clarifying questions per task Tactic #3: Template Engineering - Identify top 3 repetitive tasks - Create first template - Use template successfully - Day 1-2: Analyze work, identify top 3 tasks - Day 3-5: Create template for #1 task (invest 3-4 hours) - Day 6-7: Use template on real work, measure results - Top 3 tasks identified - One high-quality template created - Template used at least twice successfully Integration and Measurement - All three tactics working together - Measure compound impact - Share learnings with team - Day 1-2: Create templates #2 and #3 - Day 3-4: Use all tactics on larger feature - Day 5-7: Measure improvement, document lessons - 3 templates in library - Agent writes 80%+ of code - 70%+ first-time success rate - Output doubled from baseline ### Success Indicators Code written by agent 0-20% 50%+ 90%+ First-time success rate 20-30% 50%+ 80%+ Features completed per week 1-2 3-4 5-10 Templates in library 0 3-5 10-15 Mindset Think like coder Transitioning to orchestrator Fully orchestrator mindset Team adoption Individual practice Sharing templates Team using templates regularly --- ## COMMON PITFALLS AND SOLUTIONS ### Pitfall 1: Trying to Learn Everything at Once Attempt to master all 7 tactics simultaneously Read all lessons, try all techniques, get overwhelmed Result: Progress on nothing, frustrated, quit FOCUS ON THREE FUNDAMENTALS ONLY - Week 1: Stop Coding - Week 2: Agent Perspective - Week 3: Templates - Week 4: Integration Master these before touching advanced tactics 80% of value from 20% of tactics ### Pitfall 2: Skipping Template Creation "I don't have time to create templates" Continue manual approach for everything Never invest the 2-4 hours to create template Result: Linear scaling, no leverage FORCE YOURSELF TO CREATE FIRST 3 TEMPLATES - Block 4 hours on calendar - Create template for most frequent task - Use it 5 times (break-even at 2 uses) - Measure time savings - Motivation to create more ### Pitfall 3: Insufficient Context in Prompts Write vague prompts: "Add the feature", "Fix the bug" Agent fails or asks many questions Blame agent for not understanding Result: Low success rate, frustration ALWAYS USE AGENT PERSPECTIVE CHECKLIST Before every prompt ask: - Can agent see what it needs? - Have I referenced example files? - Is success criteria clear? - Are constraints specified? Takes 60 seconds, saves 30 minutes ### Pitfall 4: Not Measuring Results Adopt tactics without measuring "Feels faster" but no data Can't prove value to team or management Result: Can't optimize, can't scale adoption TRACK 4 KEY METRICS FROM DAY 1 1. Code source ratio (agent vs human) 2. First-time success rate 3. Features completed per week 4. Time savings per template use Takes 2 minutes per day Proves value quantitatively ### Pitfall 5: Perfectionism on Templates Spend 20 hours creating perfect template Worry about every edge case Never finish, never use Result: Zero ROI, wasted time START WITH "GOOD ENOUGH" TEMPLATE - 2-4 hours maximum for first version - Cover 80% of cases - Use on real work - Improve based on failures - Version 1.0 → 1.1 → 1.2 → 2.0 over time Working template that improves > perfect template that doesn't exist --- ## CONCLUSION

The 80-20 rule is fundamental to success in agentic coding. Master three core tactics first: 1. **Stop Coding (35%):** Transition from typer to orchestrator 2. **Agent Perspective (25%):** Think from agent's viewpoint always 3. **Template Engineering (20%):** Solve classes, not instances Together: **80% of total agentic coding value** These three create multiplicative effects (10x × 3x × 10x = 300x) and form the foundation for all advanced tactics.

**YOUR NEXT STEPS:** **This Week:** - Stop typing implementations, let agent code - Track agent vs human code ratio - Measure baseline output **Next Week:** - Add context to all prompts - Track first-time success rate - Reference example files **Week 3:** - Identify top 3 repetitive tasks - Create first template (invest 3-4 hours) - Use template at least twice **Week 4:** - Create templates #2 and #3 - Measure compound improvement - Share templates with one teammate **Month 2:** - Expand template library to 10-15 - Achieve 80% first-time success rate - Team adoption growing **Month 3:** - Master three fundamentals - Begin learning advanced tactics - Output increased 5-10x "80% of results come from 20% of efforts." Focus on the fundamentals. Master Stop Coding, Agent Perspective, and Templates before anything else. These three tactics alone will transform your engineering output from linear to exponential. Everything else is optimization. --- - [ ] Understand Pareto Principle application to TAC - [ ] Can identify the three core tactics - [ ] Understand why these three deliver 80% of value - [ ] Can explain multiplicative effect - [ ] Know 80-20 within each tactic - [ ] Have week-by-week implementation plan - [ ] Can measure success - lesson-01-hello-agentic-coding.md - lesson-02-twelve-leverage-points.md - lesson-03-success-is-planned.md - template-engineering-guide.md