The 9 Principles of Being a 10X Human

01Cut the Slack Thread, Ask the Agent

Legacy spaghetti or brand-new greenfield — the agent reads it faster than anyone can explain it.

Stop waiting for people to get back to you. Ask the agent, get answers in seconds, and move on.

Most people's first instinct when they join a new project is to message the team lead, book a walkthrough call, or spend days reading docs. The agent eliminates that entire waiting period. Point it at any repo — legacy monolith, microservices mesh, brand-new greenfield — and it builds a mental model in minutes.

This doesn't mean you stop talking to your team. Collaboration, mentorship, and shared context are irreplaceable. But the agent handles the "what does this code do?" questions so your conversations with colleagues can focus on the "why did we build it this way?" questions that actually matter.

Start with /init

In Claude Code, running /init on any repository generates a CLAUDE.md file — an instant summary of the project's architecture, conventions, key files, and how things connect. It's the equivalent of a senior engineer giving you a 30-minute walkthrough, except it takes 60 seconds and you can query it further.

This is your first move on any codebase. Once the agent has built that context, every follow-up question becomes sharper. (See Principle 5: Context Quality = Output Quality for how to maintain and evolve this context over time.)

This applies to everyone, not just developers.

• Developers use it to onboard, trace bugs, plan refactors
• QA uses it to understand what a feature actually does before writing tests
• DevOps uses it to understand what a service deploys and what it depends on
• PMs use it to understand what changed between two versions, in plain English

Questions worth asking your agent about any codebase

Understanding the repo

"Explain this repository's architecture. What does it do, how is it structured,
 and what are the most important files I should know about?"

"Draw me a Mermaid diagram of how the main services interact."

"What is the data flow when a user submits an order?"

Understanding specific code

"Explain this function. What does it do, what are its inputs and outputs,
 and are there any edge cases or risks I should know about?"

"What calls this function, and what does it do with the result?"

"What would break if I changed this interface?"

For QA — understanding what to test

"Read this service and give me every possible failure mode.
 What are the edge cases a human tester would miss?"

"What are the happy path and all the error paths through this endpoint?"

For DevOps — understanding what runs

"Read this Helm chart and tell me what it deploys, what ports it exposes,
 and what it depends on."

"What does this GitHub Actions workflow do, step by step?"

For PMs — understanding what changed

"Summarise the last 30 commits in plain English, grouped by feature area."

"What changed between v1.4 and v1.5 that a non-technical stakeholder should know about?"

Beyond engineering: understanding across departments

Marketing

"Explain our competitor's product page. What are they emphasizing?
 How does their messaging differ from ours?"

"Read their blog and social strategy. What themes are they doubling down on?"

Sales

"Read this customer's website, their LinkedIn, and their recent press releases.
 Give me 5 personalized talking points for my call."

"What does this prospect's tech stack look like based on their job postings?"

Legal / Compliance

"Read this regulatory document and explain what it means for our data processing practices."

"Compare our privacy policy to GDPR Article 17. Where are the gaps?"

The mindset shift

02Feedback Loops Are What Make You 10X

This is the single biggest differentiator between a normal AI user and a 10X engineer.

An agent without a feedback loop is just a fast typist.

An agent with a feedback loop is an autonomous engineer.

The principle: give your agent the tools to verify its own work, so it can iterate without you.

Without the loop: you are the feedback mechanism. That's a bottleneck. With the loop: the agent is the feedback mechanism. You just review the outcome.

Example: Browser DevTools MCP as the ultimate feedback loop

This is one of the most powerful examples of a feedback loop in action. With a DevTools MCP server connected, your agent can:

• Read console errors — the agent sees every TypeError, warning, and failed assertion in real time, then traces it back to the source code and fixes it
• Inspect network requests — see every API call, spot 4xx/5xx responses, check payloads, and fix the endpoint or the request without you ever opening the Network tab
• Check localStorage and sessionStorage — verify that auth tokens, user preferences, and cached data are being stored and read correctly
• Run Lighthouse audits — get performance, accessibility, SEO, and best-practice scores, then immediately act on every recommendation
• Take screenshots — visually verify that the UI renders correctly after every change, catching layout breaks before you do

The key insight: instead of you opening Chrome, inspecting the console, finding the error, copying it, and pasting it back to the agent — the agent does that entire loop itself. It writes code, checks the browser, sees the error, fixes the code, and re-checks. You just review the final result.

Verification tools by role

Developers — code correctness

QA — feature correctness

DevOps — infrastructure correctness

Security — vulnerability correctness

Performance & analytics

Example: agent with and without a feedback loop

WITHOUT a feedback loop
─────────────────────────────────────────────────────────
You:   "Build me a user registration endpoint"
Agent: [writes code, says it's done]
You:   [copy paste → run → crash → debug → 2 hours lost]

WITH a feedback loop
─────────────────────────────────────────────────────────
You:   "Build me a user registration endpoint.
        After writing the code, run the test suite.
        If any tests fail, fix them and re-run.
        Only tell me when all tests are passing."

Agent: [writes code]
       → [runs tests: 3 failures]
       → [reads failure output, identifies root cause]
       → [fixes code]
       → [re-runs tests: all passing]
       → "Done. Here's what I changed and why."

You:   [review a working, tested endpoint — 5 minutes]

03Tools Give Your Agent Hands

An agent without tools is like a developer without a computer.

MCP (Model Context Protocol) is the standard that lets your agent connect to anything.

The right tools turn your agent from an advisor into a doer.

Without tools, your agent is blind and below average

Here's the uncomfortable truth: an agent with no tools can only work with what you paste into it. It can't look anything up, can't verify anything, and can't act on anything. It's a brain in a jar. The output will be generic, surface-level, and often wrong — because it has no way to ground its answers in reality.

But the moment you connect it to the right combination of tools, the quality jumps from below average to exceptional. One tool alone won't do it — it's the stack of tools that creates the compounding effect.

Example: hiring and finding talent

Say you want your agent to help you find and recruit a senior DevOps engineer. With just LinkedIn access via a single MCP tool, the agent can search profiles and send messages. That's better than nothing, but the results will be mediocre — generic outreach to candidates who may have bounced emails, outdated profiles, or no real intent to move.

Now stack the tools:

• Unipile MCP — unified access to LinkedIn, email, and WhatsApp. The agent can search candidates, read their activity, and reach out across multiple channels
• NeverBounce — the agent verifies every email before sending, so zero bounces and your sender reputation stays clean
• FullEnrich / Apollo / Clearbit — the agent enriches every candidate with company data, tech stack, funding stage, team size, and recent job changes
• Google Calendar MCP — the agent checks your availability and proposes interview slots directly in the outreach

With one tool: you get a list of names. With the full stack: the agent researches candidates, verifies their contact info, writes personalised outreach grounded in their actual experience, sends across the right channel, and books the call — all without you touching a keyboard. (The power here comes with responsibility — always respect data privacy regulations and candidate consent in your region.)

This pattern repeats across every department. A marketing agent with just a writing tool produces generic content. Add SEO tools, analytics, competitor monitoring, and a CMS — and it produces content that actually ranks. Tools aren't optional — they're what separate a toy demo from a real 10X workflow.

Tools by role and use case

Developers

QA engineers

DevOps

Project managers

Marketing

Hiring & recruiting (bonus use case)

04Workflows Are Your Identity

Imagination is the only limit on what you can automate.

Your workflow is how you work — make it yours, feel proud of it, and keep improving it.

The engineer with the best workflow consistently beats the engineer with the best raw skills.

The foundation: one master pattern

Every great workflow follows the same shape, regardless of role:

Know → Plan → Verify (human) → Execute → Check → Ship

The difference is what "execute" and "check" mean for your specific role.

Workflows by role

Developer

QA

DevOps

Project manager

Marketing

Sales

The developer workflow — fully elaborated

This is the most powerful example of a complete agentic workflow.

Step 1 — Build Knowledge
  Agent reads: the ticket, the relevant files, the CLAUDE.md, any linked specs
  Agent does NOT start writing code yet

Step 2 — Think & Plan
  Agent produces: a written plan
    - Which files will be changed
    - What the approach is
    - What edge cases to watch for
    - What tests will be written

Step 3 — Human Verification  ← most people skip this and regret it
  You read the plan. You approve or correct it.
  This is your 5-minute investment that saves 2 hours of wrong code.

Step 4 — Generate Code
  Agent implements exactly what was planned
  No surprises — you approved the plan

Step 5 — Write Tests
  Agent writes unit tests, integration tests, edge case tests
  Derived from the acceptance criteria in the ticket

Step 6 — Run & Iterate
  Agent runs the test suite
  Reads failures, understands why, fixes the code
  Re-runs until all passing — no human involved

Step 7 — Screenshot + Visual Verify (for UI work)
  Agent screenshots the result using Browser/DevTools MCP
  Compares to Figma spec
  Iterates until it matches

Step 8 — Commit & PR
  Clean commit message, linked to ticket
  PR description auto-generated with: what changed, why, how to test

The UI / frontend workflow (with Figma + DevTools MCP)

The agent sees what you see. It doesn't guess — it looks.

1. Read Figma via MCP — Extract specs, colours, layout
2. Screenshot current state — See what actually renders
3. Identify the delta — Spec vs reality
4. Write or fix component
5. Screenshot result
6. Does it match? No → go back to step 3. Yes → check DevTools for console errors and layout shifts. Done.

05Context Quality Equals Output Quality

A confused agent produces confused output.

A well-briefed agent produces production-quality output.

Context is your responsibility — and it's not hard to get right.

The rule: give your agent enough to understand the task and your conventions — nothing more.

MD files are your best friends

Claude Code reads markdown files automatically from your repo. This is your context layer — and it's hierarchical.

Enterprise / Org level
  └── Global rules that apply to every repo
      Coding standards, security rules, language decisions

  Repo level — CLAUDE.md (root of every project)
  └── What this project does, how it's structured,
      key files, commit conventions, test patterns

      Folder level — CLAUDE.md (inside specific folders)
      └── What this module does, specific patterns,
          what not to touch

          Local — claude.local.md (gitignored, your machine only)
          └── Your personal preferences, local paths,
              API keys for dev, tools you prefer

CLAUDE.md — what to put in it

## What this project does
One paragraph. Be specific.

## Architecture
Link to a Mermaid diagram or describe the main services.
Which folder does what.

## Key files
- `src/api/` — route handlers, Express router
- `src/services/` — business logic only, no DB here
- `src/models/` — schemas only

## Conventions
- TypeScript, strict mode, no `any`
- Tests live alongside source: `*.test.ts`
- Commits: feat / fix / chore / test prefix
- All functions must have JSDoc

## Running the project
What commands to run, in what order.

## Do not touch
Files or folders that are off-limits and why.

Skills — reusable agent superpowers

A skill is a markdown file that tells an agent how to do a specific task, step by step. Write it once. Use it forever. Share it with your team.

Examples of skills worth building

Three sources of skills

1. Build your own — codify what you already do well. Your best work, turned into a repeatable process.
2. Share with your team — when you have a great skill, your team inherits it instantly. Skills compound.
3. Use industry-proven skills — the AI community publishes battle-tested skills for common engineering tasks. Don't reinvent what's already great.

06Review Like Your Production Depends on It

Tests verify correctness. Humans verify judgment.

An agent can make every test pass and still build the wrong thing.

Your review is not a rubber stamp — it's your highest-leverage activity.

Wait — doesn't reviewing slow you down?

This is the most common pushback: "If I have to review everything the agent produces, am I really 10X? Isn't that just adding a bottleneck?"

No. And here's why: reviewing is not the same as doing.

Without the agent, you spend 4 hours writing the code, 1 hour testing it, and 30 minutes reviewing your own work. That's 5.5 hours.

With the agent, it writes the code in 5 minutes, runs all the tests, self-corrects, and hands you a finished result. You spend 15 minutes reviewing. That's 20 minutes total. Even with the review, you're 16X faster — not slower.

The review is what makes the speed safe. Without it, you ship faster but you ship bugs, security holes, and architectural debt. Then you spend 3 days firefighting what took 5 minutes to generate. That's not 10X — that's 0.1X with extra steps.

Review is the principle that protects all the other principles. It's what separates "fast and reckless" from "fast and reliable." The 10X isn't in skipping the review — it's in the fact that you're reviewing instead of writing. Your role shifts from producer to quality gate, and that's where the leverage lives.

Passing tests don't catch everything. A 10X human reviews AI output critically.

What automated tests CAN'T catch

• Bad architecture decisions — the code works but creates technical debt that compounds
• Security holes — SQL injection that no test covers, auth bypass in edge cases
• Over-engineering — 500 lines when 50 would do, abstraction layers nobody asked for
• Style mismatch — code that works but doesn't fit the patterns of the codebase
• Subtle logic bugs — off-by-one errors in pagination, race conditions under load
• Missing requirements — the code does what was asked, but not what was needed

The example that passes every test but fails production

// Agent-generated code — all tests pass ✓
async function getUsers(req, res) {
  const users = await db.query("SELECT * FROM users"); // ← no pagination
  for (const user of users) {
    user.orders = await db.query(                       // ← N+1 query
      "SELECT * FROM orders WHERE user_id = " + user.id // ← SQL injection
    );
    user.password_hash = user.password;                 // ← leaking hash
  }
  return res.json(users);                              // ← unbounded response
}

// Tests: ✓ returns users, ✓ includes orders, ✓ responds 200
// Production: crashes at 10k users, vulnerable to injection,
//             leaks credentials, no rate limiting

Review checklist by role

The mindset shift

Beyond engineering: critical review across departments

Marketing

Agent drafts a campaign — you verify brand voice, legal compliance, audience targeting accuracy, and that messaging won't be misinterpreted out of context.

Sales

Agent creates a proposal — you verify pricing accuracy, contract terms, customer-specific requirements, and that nothing contradicts what was discussed on the call.

HR

Agent writes a job description — you verify legal compliance, inclusive language, accurate requirements, and that the role level matches compensation bands.

07Agent Failures Are Your Best Context

Every agent failure is a gift wrapped in frustration.

Fix the bug, sure. But then ask: "How do I make sure this never happens again?"

The answer is always context.

Every mistake is a flywheel opportunity. The 10X response to failure isn't just to fix — it's to prevent.

The flywheel

Every failure that you convert into context makes the agent permanently better at working in your codebase. This is compound interest for AI productivity.

The mindset shift

Failure types and what to update

The feedback loop in practice

Monday:
  Agent writes a React component using class syntax.
  You fix it and add to CLAUDE.md: "Always use functional components with hooks."

Tuesday:
  Agent puts business logic in the API route handler.
  You refactor and add: "Business logic belongs in src/services/. Routes are thin."

Wednesday:
  Agent writes tests that depend on execution order.
  You fix and add: "Each test must be independently runnable. No shared state."

Thursday:
  Agent uses the correct patterns for all three scenarios.
  The flywheel is spinning.

Beyond engineering: the flywheel everywhere

PM

Agent creates bad tickets with vague acceptance criteria → Update your create-ticket.md skill with examples of good vs bad ACs. Next time, the agent writes tickets your devs actually understand.

Sales

Agent misprices a proposal because it used last quarter's rates → Add pricing rules to your sales context: "Always use the pricing sheet at /docs/pricing-2026-Q2.md. Never use cached pricing."

Marketing

Agent goes off-brand in a blog draft → Add your brand voice guide to context: "We are direct, technical, and never use buzzwords. See /docs/brand-voice.md for examples."

08Know When NOT to Use the Agent

A 3-line config change doesn't need an agent.

The strongest signal of an expert is knowing when to just do the thing.

Over-delegating to AI is the new over-engineering.

The wisest use of a 10X tool is knowing when not to use it.

When to skip the agent

The mindset shift

The over-delegation trap

The trap:
─────────────────────────────────────────────────────────
You spend 10 minutes writing a detailed prompt for the agent
to do a task that would take you 2 minutes to do manually.

Net result: 8 minutes wasted + you still have to review the output.

The expert move:
─────────────────────────────────────────────────────────
You do the 2-minute task yourself.
You use the saved 8 minutes to have the agent work on something
that would take you 2 hours.

That's 10X thinking.

When AI amplifies vs when it wastes

Beyond engineering: the same rule applies everywhere

• PM doesn't need AI to move a Jira card to "In Progress". Just drag it.
• Designer doesn't need AI to pick between two button colours. Trust your eye.
• HR doesn't need AI to schedule a 1:1. Just send the invite.
• Sales doesn't need AI to log a call note that says "Good conversation, following up Thursday."
• Marketing doesn't need AI to fix a typo in a tweet. Just fix it.

09Parallelism Is Real 10X

One agent working sequentially is faster than working alone.

Multiple agents working in parallel is a different category entirely.

This is where 10X becomes real.

The tools that make this possible: Warp, tmux, Claude Code multi-agent, git worktrees.

The parallel agent model

Instead of one agent doing everything in sequence, you spawn multiple agents — each focused on one thing — and they work simultaneously.

What used to take 4 hours sequentially now takes the time of the longest single task.

The tools that enable this

Warp — the terminal built for AI

• Run multiple Claude Code sessions in split panes simultaneously
• Each pane is its own agent, its own context, its own task
• AI-native: command autocomplete, natural language to command, shared context
• Built for exactly this kind of multi-agent terminal workflow

tmux — the original parallel terminal

• Create multiple windows and panes in one terminal session
• Attach and detach from long-running agent sessions — agent keeps working while you're away
• Script your session layout: tmux new-session, split-window, launch agents in each pane
• Essential for running agents in the background on a server or remote machine

Git worktrees — parallel branches, no stashing

# Instead of switching branches and losing context:
git worktree add ../project-feature-auth feature/auth
git worktree add ../project-feature-payments feature/payments

# Now you have two complete working copies of the repo
# Agent 1 works in ../project-feature-auth
# Agent 2 works in ../project-feature-payments
# No conflicts. No stashing. No waiting.

Worktrees are the unlock for true parallel agent development. Each agent gets its own isolated working copy of the repo. They can build, test, and commit independently.

What to parallelise — by role

Engineering

Goal: Ship a feature

Agent 1 → Read Figma, build the UI component
Agent 2 → Build the API endpoint
Agent 3 → Write unit and integration tests
Agent 4 → Update the API docs and changelog
Agent 5 → Prepare staging deployment config

Marketing

Goal: Launch a content campaign

Agent 1 → Write the blog post (pillar content)
Agent 2 → Create social media posts (LinkedIn, X, threads)
Agent 3 → Design the email campaign (subject lines, body, CTA)
Agent 4 → Optimise the landing page for SEO
Agent 5 → Pull baseline analytics for measurement

Project management

Goal: Kick off a new project

Agent 1 → Draft the project spec and requirements doc
Agent 2 → Break requirements into Jira epics and tickets
Agent 3 → Draft the communication plan and stakeholder update
Agent 4 → Generate the project plan with milestones
Agent 5 → Identify risks and open questions

Hiring / recruiting

Goal: Source and engage candidates for a role

Agent 1 → Search and shortlist candidates via Unipile + FullyEnrich
Agent 2 → Enrich profiles with contact data and background
Agent 3 → Draft personalised outreach messages per candidate
Agent 4 → Update the candidate tracker in Notion/Sheets
Agent 5 → Schedule intro calls via Calendar MCP

Security & compliance

Goal: Pre-release security review

Agent 1 → SAST scan with Semgrep
Agent 2 → Container vulnerability scan with Trivy
Agent 3 → DAST scan on staging with OWASP ZAP
Agent 4 → Check for secrets in git history
Agent 5 → Generate the security review report

The mental model

Every hour you work sequentially is an hour you're leaving on the table.

The Complete Framework

Nine principles. One system. Every role.