Agentic AI: When Your Code Writes, Tests, and Deploys Itself

# Install
npm install -g @anthropic-ai/claude-code

# Start a session in your project
cd my-project
claude

# Give it a task
> Add rate limiting to the /api/users endpoint.
> Use Redis with a sliding window algorithm.
> Add tests and update the API docs.

┌───────────┐     MCP      ┌─────────────┐
│           │◄─────────────►│   GitHub     │
│           │               └─────────────┘
│  Claude   │     MCP      ┌─────────────┐
│  Code     │◄─────────────►│   Figma      │
│           │               └─────────────┘
│           │     MCP      ┌─────────────┐
│           │◄─────────────►│   Postgres   │
└───────────┘               └─────────────┘

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-github"],
      "env": { "GITHUB_TOKEN": "ghp_..." }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-postgres"],
      "env": { "DATABASE_URL": "postgresql://..." }
    }
  }
}

┌──────────┐
│  THINK   │ ← Analyze the task, read code, form a plan
└────┬─────┘
     │
┌────▼─────┐
│   ACT    │ ← Write code, run commands, call tools
└────┬─────┘
     │
┌────▼─────┐
│ OBSERVE  │ ← Check results, read test output, verify
└────┬─────┘
     │
┌────▼─────┐
│  DECIDE  │ ← Success? Move on. Failure? Loop back to THINK
└──────────┘

Task: "Add email validation to the signup form"

THINK: I need to find the signup form component and the
       form validation logic. Let me read the codebase.

ACT:   Read app/components/signup-form.tsx
       Read app/lib/validation.ts
       Read app/api/auth/signup/route.ts

OBSERVE: The form uses React Hook Form with Zod schemas.
         Validation is in validation.ts. No email validation
         exists yet.

THINK: I'll add a Zod email schema, update the form, and
       add server-side validation too.

ACT:   Edit validation.ts — add email regex + MX check
       Edit signup-form.tsx — add email field with validation
       Edit route.ts — add server-side email validation
       Run: pnpm test

OBSERVE: 2 tests failed — the existing signup test doesn't
         include an email field.

ACT:   Edit signup.test.ts — add email to test fixtures
       Run: pnpm test

OBSERVE: All tests pass. Done.

┌──────────────┐
│  Planner     │ ← Breaks the task into subtasks
└──────┬───────┘
       │
  ┌────┼────────────┐
  │    │             │
┌─▼──┐ ┌──▼──┐ ┌────▼───┐
│Code│ │Test │ │Review  │
│Agent│ │Agent│ │Agent   │
└──┬─┘ └──┬──┘ └────┬───┘
   │      │         │
   └──────┼─────────┘
          │
   ┌──────▼──────┐
   │  Integrator │ ← Combines results, creates PR
   └─────────────┘

import Anthropic from '@anthropic-ai/sdk'

const client = new Anthropic()

const tools = [
  {
    name: 'read_file',
    description: 'Read a file from the filesystem',
    input_schema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: 'File path to read' },
      },
      required: ['path'],
    },
  },
  {
    name: 'write_file',
    description: 'Write content to a file',
    input_schema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: 'File path to write' },
        content: { type: 'string', description: 'Content to write' },
      },
      required: ['path', 'content'],
    },
  },
  {
    name: 'run_command',
    description: 'Run a shell command',
    input_schema: {
      type: 'object',
      properties: {
        command: { type: 'string', description: 'Command to execute' },
      },
      required: ['command'],
    },
  },
]

async function runAgent(task: string) {
  const messages: Anthropic.MessageParam[] = [
    { role: 'user', content: task },
  ]

  while (true) {
    const response = await client.messages.create({
      model: 'claude-sonnet-4-20250514',
      max_tokens: 4096,
      tools,
      messages,
    })

    // Check if the agent wants to use tools
    if (response.stop_reason === 'tool_use') {
      const toolResults = []

      for (const block of response.content) {
        if (block.type === 'tool_use') {
          const result = await executeTool(block.name, block.input)
          toolResults.push({
            type: 'tool_result' as const,
            tool_use_id: block.id,
            content: result,
          })
        }
      }

      // Add assistant response and tool results to conversation
      messages.push({ role: 'assistant', content: response.content })
      messages.push({ role: 'user', content: toolResults })
    } else {
      // Agent is done
      console.log('Agent completed:', response.content)
      break
    }
  }
}

Input: "Users report login fails after password reset"

Agent workflow:
1. Search codebase for password reset logic
2. Read the reset endpoint and auth middleware
3. Find the bug: session token not invalidated after reset
4. Write the fix
5. Add a regression test
6. Run the test suite
7. Create a commit with a descriptive message

Input: GitHub Issue #87 — "Add dark mode toggle"

Agent workflow:
1. Read the issue via MCP GitHub server
2. Analyze existing theme system
3. Create a ThemeToggle component
4. Add theme context with localStorage persistence
5. Update the layout to use the theme provider
6. Test in dev server
7. Open a PR linked to the issue

Input: "Update all outdated dependencies"

Agent workflow:
1. Run `npm outdated` to list stale packages
2. Read changelogs for breaking changes
3. Update packages one by one
4. Run tests after each update
5. Fix any breakages
6. Create one commit per dependency (for easy revert)

Input: PR #234 ready for review

Agent workflow:
1. Read the PR diff via GitHub MCP
2. Understand the intent from the PR description
3. Check for bugs, security issues, and style violations
4. Verify tests cover the changes
5. Post a review with specific, actionable comments

# Agent safety configuration
permissions:
  file_system:
    read: true
    write: true
    delete: false          # Never delete files autonomously

  commands:
    allow:
      - "npm test"
      - "npm run lint"
      - "npm run build"
    deny:
      - "rm -rf"
      - "git push --force"
      - "DROP TABLE"

  git:
    commit: true
    push: false            # Require human approval for push
    force_push: never

  network:
    allow:
      - "api.github.com"
      - "registry.npmjs.org"
    deny_all_other: true

Agent works autonomously:
  ✓ Reading code
  ✓ Writing code
  ✓ Running tests
  ✓ Creating commits

Agent asks for approval:
  ? Pushing to remote
  ? Deploying to staging
  ? Modifying infrastructure
  ? Accessing production data

70% Writing code
15% Reading code
10% Debugging
 5% Architecture and design

10% Writing code (complex, novel logic)
20% Reviewing agent output
25% Architecture and design
20% Defining tasks and requirements
15% Testing and validation
10% Agent configuration and tooling