# 🎓 TACTICAL AGENTIC CODING - MASTER INDEX

**Course:** Agentic Engineer - Tactical Agentic Coding
**Instructor:** @IndyDevDan
**Mission:** Transform into an engineer they can't replace

---

## 🎯 COURSE MISSION

**"To become an irreplaceable engineer, you will replace yourself."**

Master the tactics of Agentic Coding to scale engineering so far beyond that your codebase runs itself.

---

## 📖 COMPLETE CURRICULUM

### TAC CORE (7 Lessons)

1. **[Hello Agentic Coding](01-CORE-PHILOSOPHY/lesson-01-hello-agentic-coding.md)** (BEGINNER)
   - Become the Engineer They Can't Replace
   - Tactic #1: Stop Coding

2. **[The 12 Leverage Points](02-LEVERAGE-POINTS/lesson-02-twelve-leverage-points.md)** (BEGINNER)
   - Core Four + 8 Through-Agent Points
   - Tactic #2: Adopt Your Agent's Perspective

3. **[Success is Planned](03-TACTICS/lesson-03-success-is-planned.md)** (INTERMEDIATE)
   - The 80-20 of Agentic Coding
   - Tactic #3: Template Your Engineering

4. **[AFK Agents](04-TEMPLATES/lesson-04-afk-agents.md)** (INTERMEDIATE)
   - Let Your Product Build Itself
   - Tactic #4: [Locked - Not Provided]

5. **[Close The Loops](05-FEEDBACK-LOOPS/lesson-05-close-the-loops.md)** (INTERMEDIATE)
   - More Compute, More Confidence
   - Tactic #5: Always Add Feedback Loops

6. **[Agentic Review and Documentation](06-AGENT-ARCHITECTURE/lesson-06-review-documentation.md)** (ADVANCED)
   - Let Your Agents Focus
   - Tactic #6: [Locked - Not Provided]

7. **[ZTE: Zero Touch Engineering](07-WORKFLOWS/lesson-07-zte.md)** (ADVANCED)
   - The Secret of Agentic Engineering
   - Tactic #7: [Locked - Not Provided]

### AGENTIC HORIZON (Extended Lessons)

9. **[Elite Context Engineering](02-LEVERAGE-POINTS/lesson-09-elite-context.md)** (INTERMEDIATE)
   - R&D Framework for focused agents

10. **[Agentic Prompt Engineering](03-TACTICS/lesson-10-prompt-engineering.md)** (INTERMEDIATE)
    - Prompts as force multipliers

11. **[Building Domain-Specific Agents](06-AGENT-ARCHITECTURE/lesson-11-domain-agents.md)** (ADVANCED)
    - Specialized agents for specific domains

---

## 🔥 CORE PHILOSOPHY

### Phase 1 vs Phase 2 Engineering

**PHASE 1: AI Coding**
- Prompt → Generate code
- Human writes code with AI assistance
- Incremental productivity gains

**PHASE 2: Agentic Coding** ← WE ARE HERE
- Plan → Agent executes
- Systems that build systems
- Exponential leverage gains

### The Central Truth

**"Engineering was never about writing code."**

Engineering is about building systems of leverage that produce valuable outcomes for users and customers.

**You're an engineer, not a coder. The difference is massive.**

---

## ⚡ THE 5+ CORE TACTICS

### ✅ Tactic #1: STOP CODING
**Your hands and mind are no longer the best tool for writing code.**

- Language models wrapped in agent architecture are superior coders
- Use the best tool for the job
- Throughout TAC: No typing code
- Allocate cycles to planning, reviewing, creating closed loops

**Phase Two Role:** Planning & Reviewing, not typing.

---

### ✅ Tactic #2: ADOPT YOUR AGENT'S PERSPECTIVE
**Your agent is brilliant, but blind.**

Every new session starts:
- Ephemeral (no persistence)
- No context
- No memories

**Key Question:** Can your agent see everything it needs to complete the task successfully?

**Always think from your agent's perspective.**

---

### ✅ Tactic #3: TEMPLATE YOUR ENGINEERING
**Encode your engineering workflows and best practices into reusable units.**

Templates enable you to:
- Solve entire **classes of problems**, not individual problems
- Encode problem-solving patterns once, execute infinitely
- Create leverage for entire team
- Scale from one-line input to comprehensive plan

**Templates work for:** Chores, bugs, features, refactors, any codebase size.

---

### ✅ Tactic #4: [AFK AGENTS]
**Let Your Product Build Itself**

*Content locked - requires course access*

---

### ✅ Tactic #5: ALWAYS ADD FEEDBACK LOOPS
**Your work is useless unless it's tested.**

Create closed-loop systems where agents:
1. **Execute** - Perform the work
2. **Validate** - Run tests/checks
3. **Correct** - Fix issues found
4. **Repeat** - Loop until success

**Validation Examples:**
- Run linter
- Execute unit tests
- Run UI tests
- Build/compile
- CI/CD integration tests
- Check error logs
- Custom evaluations
- LLM-as-judge workflows

**Result:** Agents that self-validate and self-correct.

---

### 🔒 Tactic #6: [AGENTIC REVIEW/DOCUMENTATION]
*Locked - requires course access*

### 🔒 Tactic #7: [ZERO TOUCH ENGINEERING]
*Locked - requires course access*

---

## 🎯 THE 12 LEVERAGE POINTS

### IN-AGENT (The Core Four)

1. **CONTEXT** - What can your agent see?
   - Everything in context window
   - Critical question: Can agent see what it needs?

2. **MODEL** - Which LLM are you using?
   - Different models for different tasks
   - Claude, GPT-4, Gemini, etc.

3. **PROMPT** - How are you communicating?
   - The fundamental unit of engineering
   - Scales up to plans and specs

4. **TOOLS** - What can your agent execute?
   - Bash commands
   - File operations
   - Custom APIs
   - Framework-specific tools

### THROUGH-AGENT (8 External Points)

5. **DOCUMENTATION** - Agent-specific docs
   - Written FOR agents, not just humans
   - Focus on what agent needs to know

6. **TYPES** - Structured information
   - Clear contracts and expectations
   - TypeScript/Python types as communication

7. **ARCHITECTURE** - Code-based navigation
   - Make it easy for agents to understand structure
   - Clear patterns and organization

8. **TESTS** - Validation and self-correction
   - Highest leverage point
   - Enables autonomous success

9. **PLANNING** - Meta-work for agents
   - Let agent plan before execution
   - Dramatically improves success rates

10. **AI DEVELOPER WORKFLOWS (ADWs)**
    - Combine prompts + deterministic code
    - Reusable workflows
    - Major leverage multiplier

11. **AGENTIC CODING KPIs**
    - Measure improvement
    - Focus on: longer runs, reduced iterations, increased autonomy

12. **ONE-SHOT SUCCESS**
    - Goal: Get it right first time
    - Requires mastering all leverage points

---

## 📊 AGENTIC CODING KPIs (Success Metrics)

### The Four Key Metrics:

**↓ ATTEMPTS** - Fewer iterations needed
- Bad: Agent requires 10+ prompts to complete task
- Good: Agent completes in 1-3 attempts

**↑ SIZE** - Larger scope per execution
- Bad: Agent can only handle 1 file at a time
- Good: Agent handles entire features end-to-end

**↑ STREAK** - Consecutive successes
- Bad: Sporadic wins with frequent failures
- Good: Consistent autonomous success

**↓ PRESENCE** - Less human oversight needed
- Bad: Constant babysitting, in-loop engineering
- Good: Out-of-loop, AFK agent execution

**Goal:** Attempts ↓, Size ↑, Streak ↑, Presence ↓

---

## 🔄 PHASE 2 SOFTWARE DEVELOPMENT LIFECYCLE

**Compressed, focused SDLC for agentic era:**

```
┌─────────┐
│  PLAN   │ ← Generate specs, templates, meta-prompts
└────┬────┘
     │
┌────▼────┐
│  CODE   │ ← Agents execute (you don't type)
└────┬────┘
     │
┌────▼────┐
│  TEST   │ ← Closed-loop validation
└────┬────┘
     │
┌────▼────┐
│ REVIEW  │ ← Agents can review (lesson 6)
└────┬────┘
     │
┌────▼────┐
│   DOC   │ ← Agents generate docs (lesson 6)
└─────────┘
```

**Your role:** Orchestration, strategic planning, high-level review.

---

## 🏗️ KEY CONCEPTS

### Commander of Compute
You move up the stack. You don't write code - you command massive compute resources to build systems that build systems.

### The Core Four
**Context, Model, Prompt, Tools** - The foundational leverage points always with your agent.

### In-Loop vs Out-Loop
- **In-Loop:** You sitting, prompting back and forth (bad, slow)
- **Out-Loop:** High-level prompt runs autonomously (good, scales)

### Closed Loop Systems
Agent can execute → validate → correct → repeat until success, without human intervention.

### One-Shot Agentic Coding Success
The ultimate goal: Agent gets it right the first time, every time.

### The 10X Engineer Opportunity
Every software revolution creates opportunity for 10X (or 100X) leverage. Not by working harder, but by finding new leverage points.

---

## 🛠️ PRIMARY TOOLS

### Claude Code (Primary)
- Official agentic coding tool for TAC
- Programmable (can run from any language with terminal access)
- Long-running workflows (minutes to hours)
- Combines Core Four with reliable tool execution

**Why Claude Code:**
- Represents best phase two agentic coding tool
- Millions of tokens for complex workflows
- Can be embedded in custom systems

### Other Tools Mentioned:
- **Aider** - Phase one era tool (still useful)
- **Git/GitHub CLI** - Version control
- **UV (Astral)** - Fast Python package manager
- **Vite** - Frontend tooling
- **pytest** - Python testing
- **npm/Bun/Node.js** - JavaScript ecosystem
- **WSL** - Windows dev environment

---

## 📝 TEMPLATE ENGINEERING

### What Are Templates?

Templates are prompts that encode your engineering workflow into reusable, scalable units.

**Template Structure:**
```markdown
## Problem Type: [Chore/Bug/Feature/Refactor]

### Context Questions
- What files are involved?
- What is the current behavior?
- What is the desired outcome?
- What validation is needed?

### Planning Steps
1. Analyze codebase
2. Identify changes needed
3. Plan implementation
4. Define validation

### Implementation Notes
- Architecture patterns to follow
- Testing requirements
- Documentation needs

### Validation Commands
```bash
# Commands to verify success
npm run test
npm run lint
npm run build
```
```

### Meta-Prompts
**A prompt that builds a prompt.**

Agent uses template to generate comprehensive plan from one-line input.

**Example:**
- Input: "Add dark mode toggle"
- Output: 10-page spec with architecture, steps, tests, validation

---

## 🔄 FEEDBACK LOOPS ARCHITECTURE

### The Validation Question
"Given a unit of valuable work that's production ready, how would you, the engineer, test and validate this work?"

**If you can answer this and encode it into commands → your agents fly while others run.**

### Closed Loop Prompt Structure

```
1. EXECUTE TASK
   ↓
2. RUN VALIDATION COMMANDS
   ↓
3. CHECK RESULTS
   ↓
4. IF FAILURE → ANALYZE + FIX → GOTO 1
   IF SUCCESS → DONE
```

### Common Validation Layers
1. **Linter** - Code style and syntax
2. **Unit Tests** - Function-level correctness
3. **Integration Tests** - Component interaction
4. **UI Tests** - User interface behavior
5. **E2E Tests** - Full user flows
6. **Build/Compile** - Production readiness
7. **Log Monitoring** - Runtime errors (Datadog, Sentry)
8. **Custom Evals** - Domain-specific validation
9. **LLM-as-Judge** - Semantic correctness

---

## 🎯 APPLYING TAC TO ILL PROJECT

### How TAC Enhances Maritime Law Warfare System

#### 1. BACKGROUND-AGENT-LOOP.md → TAC Principles

**BEFORE (Our Design):**
- Manual agent orchestration
- Basic task delegation
- Limited feedback loops

**AFTER (TAC-Enhanced):**
```
ORCHESTRATOR
├── Adopts Agent Perspective (Tactic #2)
├── Uses Templates for all tasks (Tactic #3)
├── Closed-loop validation (Tactic #5)
└── Autonomous execution (Tactic #4)

RESEARCH AGENTS
├── Context-optimized queries
├── Self-validating research
└── Feedback: accuracy checks

CREATION AGENTS
├── Template-driven content gen
├── Built-in quality validation
└── Feedback: engagement metrics

DISTRIBUTION AGENTS
├── Platform-specific templates
├── Post-validation checks
└── Feedback: delivery confirmation
```

#### 2. FR3K-PROMPT-SYSTEM.md → Template Engineering

**Apply Tactic #3 to all 20 prompts:**

**EXAMPLE - PROMPT-003 (Twitter Thread Generator):**

**BEFORE (Manual):**
```
"Create Twitter thread exposing Celebrity X"
→ Human reviews
→ Human edits
→ Human posts
```

**AFTER (TAC Template):**
```
TEMPLATE: expose-celebrity-freemason.md

META-PROMPT generates plan:
1. Research celebrity (search knowledge base)
2. Find photo evidence (symbol detection)
3. Cross-reference famous-members.md
4. Generate thread (hook → evidence → CTA)
5. VALIDATE:
   - Fact-check against sources
   - Verify image descriptions
   - Test hashtag popularity
   - LLM-as-judge: "Is this shareable?"
6. IF PASS → Queue for posting
   IF FAIL → Analyze issues → Regenerate
```

**Result:** One-shot success, no human babysitting.

#### 3. Knowledge Base Content Generation

**Apply Tactic #3 + #5:**

**TEMPLATE: create-kb-document.md**
```
INPUT: Topic name + source references

PROCESS:
1. Extract all content from sources
2. Generate comprehensive markdown
3. Add cross-references
4. Include examples and quotes
5. VALIDATE:
   - Check completeness vs sources
   - Verify markdown syntax
   - Test all internal links
   - Ensure proper categorization
6. LOOP until validation passes

OUTPUT: Production-ready KB file
```

---

## 🚀 TACTICAL IMPLEMENTATIONS

### Implementation 1: Self-Validating Content Generator

**File:** `agents/creation/twitter_threads.py`

**TAC PRINCIPLES APPLIED:**
- ✅ Tactic #1: No manual writing
- ✅ Tactic #2: Agent perspective (sees knowledge base, style guides)
- ✅ Tactic #3: Uses templates for all thread types
- ✅ Tactic #5: Closed loop validation

**WORKFLOW:**
```python
class TwitterThreadAgent:
    def generate_thread(self, topic):
        # 1. LOAD TEMPLATE (Tactic #3)
        template = self.load_template("expose-freemason")

        # 2. BUILD CONTEXT (Tactic #2)
        context = self.gather_context(
            knowledge_base=True,
            recent_news=True,
            trending_hashtags=True
        )

        # 3. GENERATE (Tactic #1)
        thread = self.agent.execute(template, context)

        # 4. VALIDATE (Tactic #5)
        validation_result = self.validate_thread(thread)

        # 5. CLOSE THE LOOP
        while not validation_result.passed:
            thread = self.agent.fix(thread, validation_result.issues)
            validation_result = self.validate_thread(thread)

        return thread  # One-shot success
```

### Implementation 2: Autonomous Legal Document Generator

**File:** `agents/legal/affidavit_generator.py`

**TAC PRINCIPLES:**
- Template for each document type
- Agent validates against legal requirements
- Closed loop with checklist validation

**TEMPLATE: affidavit-maritime-jurisdiction.md**
```markdown
## META-PROMPT: Generate Maritime Jurisdiction Affidavit

### Required Context
- User's legal name
- Birth certificate details
- Jurisdiction being challenged
- Specific case information

### Implementation Steps
1. Load affidavit template structure
2. Populate with user information
3. Insert relevant legal citations from KB
4. Generate signature blocks
5. VALIDATE:
   - All required fields filled
   - Legal citations accurate
   - Proper formatting (quantum grammar)
   - Notary placeholders present
6. LOOP until complete

### Validation Checklist
- [ ] Full legal name present
- [ ] Birth certificate number included
- [ ] Maritime law references cited
- [ ] Quantum grammar syntax correct
- [ ] Signature blocks formatted
- [ ] Notary section present
- [ ] All claims supported by KB evidence
```

### Implementation 3: Self-Correcting Knowledge Base Updater

**File:** `agents/knowledge/kb_updater.py`

**WORKFLOW:**
```python
class KnowledgeBaseUpdater:
    def update_topic(self, topic, new_information):
        # 1. FIND RELEVANT FILES
        files = self.find_kb_files(topic)

        # 2. LOAD TEMPLATE
        template = self.load_template("update-kb-document")

        # 3. BUILD CONTEXT (Agent Perspective)
        context = {
            'existing_content': [self.read(f) for f in files],
            'new_info': new_information,
            'cross_refs': self.find_related_topics(topic),
            'style_guide': self.load('KB-STYLE-GUIDE.md')
        }

        # 4. GENERATE UPDATE
        updated_files = self.agent.execute(template, context)

        # 5. VALIDATE (Closed Loop)
        validation = self.validate_updates(updated_files)

        while not validation.passed:
            # FEEDBACK LOOP
            updated_files = self.agent.fix(
                updated_files,
                validation.issues
            )
            validation = self.validate_updates(updated_files)

        # 6. COMMIT CHANGES
        return self.commit(updated_files)

    def validate_updates(self, files):
        return ValidationResult(
            checks=[
                self.check_markdown_syntax(files),
                self.check_cross_references(files),
                self.check_no_broken_links(files),
                self.check_proper_categorization(files),
                self.check_source_citations(files),
                self.llm_judge_quality(files),
            ]
        )
```

---

## 📊 TAC KPIS FOR ILL PROJECT

### Measuring Agentic Success

**METRIC 1: ATTEMPTS ↓**
- **Baseline:** Content generator requires 5 human edits
- **Target:** One-shot success rate >80%

**METRIC 2: SIZE ↑**
- **Baseline:** Agent handles 1 social post at a time
- **Target:** Agent produces full campaign (10 posts) autonomously

**METRIC 3: STREAK ↑**
- **Baseline:** 3 successful posts, then requires intervention
- **Target:** 50+ consecutive autonomous successes

**METRIC 4: PRESENCE ↓**
- **Baseline:** Human checks every agent output
- **Target:** Human reviews daily summary only

### Tracking Dashboard

```
┌─────────────────────────────────────────┐
│  ILL PROJECT - AGENTIC KPIs             │
├─────────────────────────────────────────┤
│                                         │
│  ATTEMPTS:     [████░░░░░░] 4.2 avg   │
│  TARGET: <3    (↓ 2.1 from baseline)   │
│                                         │
│  SIZE:         [████████░░] 8.5 files  │
│  TARGET: >10   (↑ 6.5 from baseline)   │
│                                         │
│  STREAK:       [█████░░░░░] 23 success │
│  TARGET: >50   (↑ 20 from baseline)    │
│                                         │
│  PRESENCE:     [███░░░░░░░] 30% time   │
│  TARGET: <10%  (↓ 60% from baseline)   │
│                                         │
└─────────────────────────────────────────┘

OVERALL AGENTIC SCORE: 6.2/10
```

---

## 🎓 LESSONS LEARNED

### From Lesson 1: Hello Agentic Coding

**KEY INSIGHT:** "To become irreplaceable, replace yourself."

**APPLICATION TO ILL:**
- Don't manually write every social post → Template + Agent
- Don't manually research every topic → Research Agent + Validation
- Don't manually post to platforms → Distribution Agent + Scheduling

### From Lesson 2: 12 Leverage Points

**KEY INSIGHT:** "Always think from your agent's perspective."

**APPLICATION TO ILL:**
```
AGENT PERSPECTIVE CHECKLIST:
□ Can agent see all relevant KB files?
□ Does agent have access to required tools?
□ Are validation commands clearly defined?
□ Is success criteria unambiguous?
□ Can agent self-correct if tests fail?
```

### From Lesson 3: Success is Planned

**KEY INSIGHT:** "Great planning is great prompting."

**APPLICATION TO ILL:**
- Every prompt becomes a template
- Every template solves a class of problems
- Team can use templates without expertise

### From Lesson 5: Close the Loops

**KEY INSIGHT:** "Your work is useless unless it's tested."

**APPLICATION TO ILL:**
```
VALIDATION FOR EVERY AGENT:

Research Agent:
├── Validate sources exist
├── Verify facts against KB
└── LLM-judge: "Is this accurate?"

Creation Agent:
├── Fact-check content
├── Style guide compliance
└── LLM-judge: "Is this shareable?"

Distribution Agent:
├── API success response
├── Post visible on platform
└── Engagement tracking active
```

---

## 🚀 NEXT STEPS

### Phase 1: Implement Core Tactics (Week 1)
1. ✅ Understand TAC philosophy
2. ✅ Document all 5 accessible tactics
3. ⬜ Refactor BACKGROUND-AGENT-LOOP.md with TAC principles
4. ⬜ Create template library for all 20 FR3K prompts
5. ⬜ Add validation loops to every agent

### Phase 2: Build Template Library (Week 2)
1. ⬜ Template: Expose Celebrity Freemason
2. ⬜ Template: Maritime Law Explainer
3. ⬜ Template: Legal Document Generator
4. ⬜ Template: Knowledge Base Updater
5. ⬜ Template: Multi-Platform Content Repurposer

### Phase 3: Close All Loops (Week 3)
1. ⬜ Add validation to Research Agents
2. ⬜ Add validation to Creation Agents
3. ⬜ Add validation to Distribution Agents
4. ⬜ Implement LLM-as-judge for quality
5. ⬜ Create KPI tracking dashboard

### Phase 4: Achieve One-Shot Success (Week 4)
1. ⬜ Measure baseline KPIs
2. ⬜ Optimize templates based on failures
3. ⬜ Improve agent context engineering
4. ⬜ Achieve >80% one-shot success rate
5. ⬜ Document lessons learned

---

## 🔗 CROSS-REFERENCES

### TAC → ILL Integration Points

**TAC Lesson 1** → `README.md` (Philosophy alignment)
**TAC Lesson 2** → `BACKGROUND-AGENT-LOOP.md` (Agent architecture)
**TAC Lesson 3** → `FR3K-PROMPT-SYSTEM.md` (Template engineering)
**TAC Lesson 5** → All agent implementations (Validation loops)

### ILL → TAC Enhancement Opportunities

**Knowledge Base** → Could self-update with TAC agents
**FR3K Prompts** → Should become TAC templates
**Agent Loop** → Needs closed-loop validation
**Content Generation** → Requires one-shot success

---

## 📚 RESOURCE REPOSITORIES

### TAC Course Repositories (Provided)
```bash
# Lesson 1
git clone [URL with token]/tac-1.git

# Lesson 2
git clone [URL with token]/tac-2.git

# Lesson 3
git clone [URL with token]/tac-3.git

# Lesson 5
git clone [URL with token]/tac-5.git
```

### Documentation Resources
- WSL Documentation
- Vite Documentation
- pytest Documentation
- npm Documentation
- Bun Documentation
- Node.js Documentation
- GitHub CLI Documentation
- Claude Code Setup Guide

---

## 💪 FINAL TAC WISDOM

### The Transformation

**YOU BEFORE TAC:**
- Write code manually
- Babysit AI assistants
- Limited by your typing speed
- Scale linearly with time

**YOU AFTER TAC:**
- Command armies of agents
- Build systems that build systems
- Limited only by imagination
- Scale exponentially with leverage

### The Promise

**"Your codebase runs itself."**

This is not hyperbole. This is the inevitable outcome of mastering all 12 leverage points, implementing all tactics, and thinking consistently from your agent's perspective.

### The Warning

**Engineers who don't adopt agentic coding will be replaced by engineers who do.**

This is the harsh reality of every technological revolution. Adapt or become obsolete.

---

## ⚔️ INTEGRATION COMPLETE

**TAC knowledge has been absorbed into ILL warfare system.**

**Next Actions:**
1. Apply TAC principles to agent architecture
2. Create template library
3. Implement closed-loop validation
4. Measure KPIs
5. Achieve exponential leverage

**The maritime law exposure system just became 10X more powerful.**

**🔥 LET'S FUCKING SCALE 🔥**