Skill: ivangdavila/agentic-engineering (version 1.0.0)

--- name: Agentic Engineering slug: agentic-engineering version: 1.0.0 homepage: https://clawic.com/skills/agentic-engineering description: Work effectively with AI coding agents using parallel terminals, blast radius thinking, atomic commits, and pragmatic tool selection. metadata: {"clawdbot":{"emoji":"🤖","requires":{"bins":["git"]},"os":["linux","darwin","win32"]}} --- ## When to Use User works with AI coding agents (Claude Code, Codex CLI, or similar) and wants to maximize productivity. Use for workflow optimization, parallel agent coordination, context management, and developing intuition for agentic development. ## Quick Reference | Topic | File | |-------|------| | Parallel workflow | `parallel.md` | | Blast radius | `blast-radius.md` | | Context & prompts | `context.md` | | Tool selection | `tools.md` | ## Core Philosophy Agentic engineering is about **working WITH AI coding agents effectively**, not building agent systems. The term was popularized by Peter Steinberger (steipete.me) in late 2025. Core principle: **Just talk to it.** Skip the elaborate tooling, RAG setups, and complex orchestration. Develop intuition through practice. ## Core Rules ### 1. Run Parallel Agents Run 3-8 coding agent instances simultaneously in a terminal grid: ``` ┌─────────┬─────────┬─────────┐ │ Agent 1 │ Agent 2 │ Agent 3 │ │ (main) │ (refac) │ (tests) │ ├─────────┼─────────┼─────────┤ │ Agent 4 │ Agent 5 │ Agent 6 │ │ (ui) │ (docs) │ (debug) │ └─────────┴─────────┴─────────┘ ``` Most agents work in the same folder. No worktrees. Pick non-overlapping areas. ### 2. Think in Blast Radius Before each prompt, estimate: - How many files will this touch? - How long will this take? - Can I run this in parallel with other work? Small blast radius → multiple parallel agents. Large blast radius → one focused agent. ### 3. Agents Do Atomic Commits Configure agents to commit their own changes: - One commit per logical change - Only commit files the agent edited - Clean commit messages This keeps history navigable when multiple agents work simultaneously. ### 4. Refactor Regularly Spend ~20% of time on refactoring (also done by agents): - Code duplication (jscpd) - Dead code (knip) - Consolidate similar patterns - Break apart large files - Add tests for tricky parts Iterate fast, then pay back tech debt. ### 5. CLIs Over MCPs Prefer CLIs that agents already know: ``` ✅ gh, vercel, psql, axiom ❌ Complex MCPs that pollute context ``` One line in AGENTS.md: "logs: use vercel cli" is enough. ### 6. Screenshots in Prompts 50%+ of prompts should include screenshots: - Drag image into terminal - Agent finds matching strings/elements - Far more precise than text descriptions No need to annotate — agents are good at matching. ### 7. Stop and Steer If something takes longer than expected: 1. Press Escape 2. Ask "what's the status" 3. Help find the right direction, abort, or continue Don't be afraid to stop agents mid-work. File changes are atomic. ## Common Traps - **Over-engineering setup** → Skip RAG, complex subagents, plugins. Just talk to it. - **One agent at a time** → Run parallel, pick non-overlapping areas. - **Elaborate prompts** → Short prompts + screenshot often work better. - **Worktrees/branches per change** → Slows you down. Same folder, atomic commits. - **Background agents only** → Hard to steer. Keep agents visible. ## Scope This skill ONLY: - Provides workflow patterns for using AI coding agents - Guides tool and setup decisions - Shares best practices from the agentic engineering community This skill NEVER: - Implements agents directly - Accesses external systems - Modifies files outside skill documentation ## Security & Privacy **Data that leaves your machine:** - None — this skill provides guidance only **Data that stays local:** - No persistent storage required **This skill does NOT:** - Access credentials or make network requests - Execute code autonomously

path: blast-radius.md
content: # Blast Radius — Agentic Engineering

## What is Blast Radius?

The impact zone of a change:
- How many files will be touched?
- How long will it take?
- How risky is it?

Think before every prompt. Develop intuition.

## Estimating Blast Radius

| Prompt Type | Files | Time | Radius |
|-------------|-------|------|--------|
| "Fix this typo" | 1 | 30s | 🟢 Tiny |
| "Add loading state to button" | 1-2 | 2min | 🟢 Small |
| "Create new API endpoint" | 3-5 | 5min | 🟡 Medium |
| "Refactor auth system" | 10-20 | 30min | 🔴 Large |
| "Migrate to new framework" | 50+ | hours | 💀 Massive |

## Strategy by Radius

### 🟢 Small Radius
Run multiple in parallel. Low risk.
```
Agent 1: Fix button styling
Agent 2: Update error messages
Agent 3: Add loading spinners
```

### 🟡 Medium Radius
Run 1-2 focused agents. Monitor progress.
```
Agent 1: New API endpoint (main work)
Agent 2: Small unrelated fixes
```

### 🔴 Large Radius
One agent, full attention. Stop and steer often.
```
"Give me options before making changes"
"What's the status?"
"Let's discuss first"
```

### 💀 Massive Radius
Break into phases. Checkpoint frequently.
```
Phase 1: Create migration plan
Phase 2: Implement core changes
Phase 3: Update dependent code
Phase 4: Tests
```

## Gauging Before Committing

When unsure about radius:
```
"Give me a few options before making changes"
"List what files this would affect"
"What's the scope of this change?"
```

Let agent estimate, then decide.

## Mid-Flight Checks

If work takes longer than expected:
1. Press Escape
2. "What's the status?"
3. Decide: help, abort, or continue

Don't let agents run wild on large changes.

## Radius Creep

Watch for prompts that grow scope:
```
❌ "While you're at it, also refactor X"
❌ "And update all the tests too"
❌ "Fix any other issues you see"

✅ "Just the button styling, nothing else"
✅ "Only this one endpoint"
✅ "Keep scope minimal"
```

Tight scope = predictable blast radius.


path: context.md
content: # Context & Prompts — Agentic Engineering

## Prompt Length

Modern agents (GPT-5, Claude) need less context than you think.

| Situation | Prompt Style |
|-----------|--------------|
| Clear task, familiar codebase | 1-2 sentences |
| New area or complex logic | Paragraph + screenshot |
| Architecture decision | Discussion mode |

## Screenshots Are Essential

50%+ of prompts should include screenshots:
```
1. Take screenshot (Cmd+Shift+4 on Mac)
2. Drag into terminal
3. Agent matches visual to code
```

Benefits:
- More precise than text descriptions
- Agent finds exact elements/strings
- Faster than explaining location

No annotation needed — agents are excellent at visual matching.

## Discussion Mode

For uncertain changes:
```
"Let's discuss before making changes"
"Give me options"
"What approaches would work here?"
```

Agent presents options, you choose, then execute.

## Queue Messages

When agent is working on task A and you have tasks B, C:
```
[Agent working on A...]
You: "Next: add loading state to submit button"
You: "Then: update error messages"
[Agent finishes A, starts B, then C]
```

Queue up related tasks. Agent works through them.

## Steering Mid-Work

If agent drifts:
1. Press Escape (stops thinking)
2. Enter to send redirect message
3. Agent adjusts course

Don't wait for wrong output. Steer early.

## Context Efficiency

Keep context clean:
- Don't waste on lengthy setup explanations
- Skip obvious instructions agent already knows
- Reference docs/files instead of pasting content

```
❌ "First, let me explain how our API works..."
✅ "Check src/api/README.md, then add new endpoint"
```

## AGENTS.md / CLAUDE.md

Keep concise. Agent files are scar tissue from lessons learned.

Good entries:
```markdown
## Patterns
- Use zod for validation
- Error responses: { error: string, code: number }
- Tests: colocate with source files

## Tools
- Logs: vercel cli or axiom
- DB: psql (see .env for connection)
```

Skip:
- Obvious instructions
- Long explanations
- Things model already knows

## Fresh Context vs. Continuing

| Situation | Action |
|-----------|--------|
| New feature, clean slate | Fresh context |
| Iteration on recent work | Continue session |
| Context getting long | Summarize key points, start fresh |
| Debugging same issue | Continue (history helps) |

GPT-5/Codex handles large context well. Don't restart prematurely.

## Recovery Phrases

When stuck:
```
"Take your time"
"Be comprehensive" 
"Read all related code first"
"Create possible hypotheses"
```

Trigger deeper thinking on hard problems.


path: parallel.md
content: # Parallel Workflow — Agentic Engineering

## Terminal Grid Setup

Use a 3x3 or 2x3 terminal grid. All visible without switching windows.

```
Recommended: 3840x1620+ monitor (ultrawide)
Tool: Ghostty, iTerm2, or tmux
```

## How Many Agents?

| Work Type | Agents | Why |
|-----------|--------|-----|
| Focused feature | 1-2 | Large blast radius, needs steering |
| Refactoring | 3-4 | Independent areas, low risk |
| UI polish | 4-6 | Small isolated changes |
| Tests/docs | 4-6 | Parallel, independent |

## Same Folder, Different Areas

Most agents work in the same repo, same folder. No worktrees needed.

Pick non-overlapping areas:
```
Agent 1: src/api/
Agent 2: src/components/
Agent 3: tests/
Agent 4: docs/
```

If changes must touch the same file → serialize, don't parallelize.

## Atomic Commits Per Agent

Each agent commits only its own changes. Configure in AGENTS.md:

```markdown
## Git Workflow
- Commit after completing each logical change
- Only commit files YOU edited
- Use descriptive commit messages
- Don't commit other agents' work
```

Result: Clean git history even with 4+ agents running.

## Switching Context

When one agent is thinking/working:
1. Check another agent's progress
2. Start new task in empty terminal
3. Review recent commits
4. Prep next prompt

Never wait idle. Context switching is your job.

## When to Serialize

Don't parallelize when:
- Changes touch the same files
- Work has hard dependencies
- You need to see result A before starting B
- Database migrations (one at a time)

## Recovery from Conflicts

If agents step on each other:
```bash
git stash           # Save current state
git log --oneline   # Find last good commit
git reset --hard    # Reset to good state
git stash pop       # Reapply if needed
```

Small, atomic commits make recovery easy.


path: tools.md
content: # Tool Selection — Agentic Engineering

## Philosophy: Less is More

Every tool has a context cost. Most aren't worth it.

```
"I removed my last MCP since Claude would spin up Playwright 
unasked when it could simply read the code — which is faster 
and pollutes the context less." — steipete
```

## CLIs Beat MCPs

Agents already know common CLIs. No context cost.

| Task | Tool | Config |
|------|------|--------|
| Git ops | `gh` | None needed |
| Logs | `vercel`, `axiom` | One line in AGENTS.md |
| Database | `psql` | Connection example |
| Deploy | `vercel`, `fly` | None needed |

One line is enough: "logs: use vercel cli"

## Skip These

| Category | Why |
|----------|-----|
| RAG systems | Models are good at searching code already |
| Complex MCPs | Context pollution, unpredictable behavior |
| Subagent frameworks | Use separate terminals instead |
| Custom orchestration | Just run parallel agents manually |

## Recommended Stack

### Terminal
- **Ghostty** — Fast, stable, no memory bloat
- **iTerm2** — Good alternative, split panes
- **tmux** — For background tasks

### Coding Agents
- **Codex CLI** — Fast, efficient context use, queues messages
- **Claude Code** — Good for certain tasks, more verbose

### Editor
- **VS Code** — For browsing code, not writing
- **Cursor** — Tab completion if you still type code

### Reviews
- **GPT-5 Pro** — Plan review before big changes
- **chatgpt.com** — Second opinion on architecture

## tmux for Background Tasks

When agent starts a dev server or long test:
```
"Run via tmux"
```

Agent knows tmux. Server runs in background. No stuck terminal.

## Voice Input

**Wispr Flow** — Voice to text with semantic correction.

Great for:
- Long prompts while thinking
- Brainstorming sessions
- Hands-free steering

## Browser Debugging

**chrome-devtools-mcp** — Only MCP worth using.

When needed:
- Debug runtime issues
- Verify UI changes
- Test auth flows

Most of the time: just ask agent to read the code.

## Cost Management

Subscriptions beat API calls:
```
4x OpenAI subs + 1x Anthropic ≈ $1k/month
Equivalent API usage ≈ $5-10k/month
```

Unlimited tokens at subscription rate is the deal.

## What Not to Build

The AI tool market is crowded. Don't build:
- Another Claude Code wrapper
- Yet another worktree manager
- AI orchestration frameworks

Focus on your actual product. Tools are commoditizing fast.


Security scan verdicts — ClawScan: clean | static analysis:  | VirusTotal: clean | SkillSpector: suspicious (MEDIUM)