Advanced Development Practices

Vibe Clauding

How agentic AI is redefining the developer workflow —
from autocomplete to autonomous engineering

Viktor Klochkov

2026 · Press S for speaker notes

Inspired by Pragmatic Vibe Clauding by Yarik Yermilov, Principal Software Engineer @ Superhuman/Grammarly

The Status Quo

The Copilot-Style Workflow

How It Works

👨‍💻 Developer opens file in IDE

✏ Starts typing → gets inline suggestions

💬 Opens chat panel → asks a question

📋 Copies answer → pastes into code

🔄 Repeats for each file, each change

Limitations

Reactive, not proactive — waits for you to type before suggesting
File-scoped context — sees the current file, not the full codebase
No execution — cannot run commands, tests, or builds
Manual orchestration — you decide what to change and where
No memory across sessions — every chat starts fresh
IDE-bound — tied to VS Code / JetBrains plugin ecosystem

The Paradigm Shift

The Rise of AI Agents

AI agents don't just suggest — they plan, execute, and iterate autonomously

🤖

Claude Code

Terminal-native agent with skills, sub-agents, and MCP integration

🔭

Cursor / Windsurf

IDE-based agents with codebase indexing and multi-file editing

🚀

Devin / OpenHands

Cloud-based autonomous agents in sandboxed environments

💫

Aider / Cline

Open-source terminal agents with git-aware editing

What they share: Autonomous task execution, multi-file awareness, tool use (shell, browser, APIs), iterative self-correction, and the ability to work on a task while you do something else.

Meet the Agent

Introduction to Claude Code

What It Is

Terminal-native — runs in your shell, not locked to an IDE
Autonomous agent — reads, writes, and executes code on its own
Full repo awareness — understands your entire codebase, not just open files
Tool-using — runs tests, builds, git commands, shell scripts
Extensible — custom skills, MCP servers, sub-agents, agent teams

Copilot vs Claude Code

	Copilot	Claude Code
Model	Reactive	Autonomous
Scope	Current file	Full repo
Execution	✗	✓ Shell, tests, git
Extensibility	Plugins	Skills + MCP
Multi-agent	✗	✓ Sub-agents & teams

Core Features

Skills & Plan Mode

Custom Skill — .claude/skills/review.yml

name: code-review
description: Review PR with project conventions
trigger: /review
steps:
  - tool: Bash
    command: gh pr diff
  - tool: Read
    glob: "CLAUDE.md"
  - prompt: |
      Review this PR against our conventions
      in CLAUDE.md. Check for:
      - Security vulnerabilities
      - Performance regressions
      - Missing test coverage
      Provide actionable feedback.

Skills = reusable, YAML-defined workflows triggered by /commands. Committed to repo, shared with the team.

Plan Mode

Think before acting — explores codebase, reads files, understands architecture
Produces a plan — lists files to change, approach, trade-offs
You approve — review the plan before any code is written
Then executes — implements the approved plan autonomously

Activating Plan Mode

# In Claude Code, just ask:
> Plan how to add JWT authentication
  to our Express API

# Or use the keyboard shortcut:
# Shift+Tab toggles plan mode

Parallel Execution

Sub-Agents

🤖 Claude Code — Orchestrator

🔍

Explore Agent

Fast codebase search & analysis

🗺

Plan Agent

Architecture & design

⌨

Bash Agent

Command execution

🛠

General Purpose

Complex multi-step tasks

⚡ How It Works

Claude spawns child agents for specific subtasks
Each agent has its own isolated context window
Agents run in parallel in the background
Results merge back into the main conversation

Why It Matters

Research a 100k-line codebase without polluting main context
Run tests in background while continuing to code
Explore multiple approaches simultaneously
Main conversation stays fast and responsive

Extensibility

MCP Servers Open Protocol

What Is MCP?

Model Context Protocol — an open standard for connecting AI agents to external tools. Think of it as USB for AI.

🤖 Any MCP-Compatible Agent

🗃 PostgreSQL

🌐 GitHub API

📄 Confluence

🔧 Jenkins

📊 Grafana

🔎 Elasticsearch

Not proprietary — works with any MCP-compatible agent
100+ community servers available today
Build your own — simple JSON-RPC protocol

Configuration — .claude/mcp.json

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-postgres",
        "postgresql://localhost/mydb"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "ghp_..." }
    }
  }
}

Usage in Claude Code

# Claude can now directly query your DB:
> Show me all users who signed up
  in the last 7 days

# Or interact with GitHub:
> Create a PR from my current branch
  with a summary of all changes

Multi-Agent Coordination

Agent Teams & Orchestrators

Lead 👑

Orchestrator

Plans & delegates tasks

→

Worker A 💻

Frontend

UI & components

→

Worker B ⚙

Backend

API & logic

→

Worker C 📊

Testing

Tests & validation

How It Works

Lead agent decomposes the task into subtasks
Workers operate in parallel git worktrees
Each worker has its own context & tools
Lead agent merges results and resolves conflicts

When to Use

Full-stack features touching many files
Large-scale refactoring across modules
Parallel implementation + test writing
Multi-service / monorepo changes

Real-World C++

C++ Refactoring with Claude Code

Before — Legacy C++ code

// Raw pointers, manual memory, C-style casts
void processData(DataManager* mgr) {
    Record* records = mgr->getRecords();
    int count = mgr->getCount();
    for (int i = 0; i < count; i++) {
        Record* r = &records[i];
        void* raw = (void*)r->payload;
        char* buf = new char[r->size];
        memcpy(buf, raw, r->size);
        if (validate(buf, r->size))
            mgr->commit((Record*)buf);
        delete[] buf;
    }
}

After — Modern C++17

// Smart pointers, ranges, type-safe casts
void processData(DataManager& mgr) {
    for (auto& record : mgr.records()) {
        auto payload =
            std::span{record.payload()};
        auto buf =
            std::make_unique<std::byte[]>(
                payload.size());
        std::ranges::copy(payload,
                          buf.get());
        if (validate({buf.get(),
                      payload.size()}))
            mgr.commit(std::move(buf));
    }
}

How it works: Claude Code explores the full codebase in plan mode, identifies all affected files, applies modernization patterns consistently, then runs your test suite to verify nothing broke — across hundreds of files in a single session.

Real-World C++

Refactoring Tasks for Claude Code

Task 1

Modernize Raw Pointers

Replace new/delete with unique_ptr, shared_ptr. Convert C-style casts to static_cast / reinterpret_cast. Fix ownership semantics across call chains.

Task 2

Apply Modern Idioms

Range-based loops, std::span, std::optional, structured bindings, [[nodiscard]], constexpr where applicable.

Task 3

Extract & Decouple

Break god-classes into focused components. Introduce interfaces for testability. Apply SOLID principles across 50+ files.

Task 4

Migrate Build System

Convert Makefiles to CMake. Update include paths, link targets, and compiler flags across the entire project.

Why Agents Excel Here

Repetitive patterns across hundreds of files
Needs full-repo context to track ownership chains
Agent can compile & test after each change

Prompt Example

Modernize all raw pointer usage in
src/core/ to smart pointers.
Run cmake --build && ctest after
each file to verify correctness.

Test-Driven Development

TDD with Claude Code

Step 1 🗺

Plan

Explore codebase & design approach

→

Step 2 📝

Write Tests

Define expected behavior first

→

Step 3 💻

Implement

Write code to make tests pass

→

Step 4 ✅

Validate

Run suite, fix failures, iterate

Key advantage: Claude Code follows this loop autonomously — it explores, writes tests, implements, runs the suite, and self-corrects failures without manual intervention.

What Claude Code Does

Reads CLAUDE.md to learn your test framework & conventions
Generates comprehensive edge-case tests
Runs the suite, reads failures, fixes code
Repeats until all tests pass

Best Practices

Document test commands in CLAUDE.md
Ask for tests before implementation
Review generated tests for correctness
Use sub-agents for parallel test suites

Case Study

Claude Built a C Compiler 100k Lines

Anthropic researcher Nicholas Carlini ran ~2,000 Claude Code sessions in a loop for two weeks — with zero human code.

What Happened

100k lines of Rust — a fully autonomous C compiler
Builds Linux 6.9 across x86, ARM, and RISC-V
Compiles real software — QEMU, FFmpeg, SQLite, PostgreSQL, Redis
Agents coordinated via git — file-based locking prevented duplicate work
Cost: ~$20,000 — 2B input tokens, 140M output tokens

Limitations

No 16-bit x86 — can't generate real-mode boot code (falls back to GCC)
No assembler/linker — depends on external toolchain
Less optimized output — slower than GCC even with optimizations off
Code quality gaps — functional Rust, but not expert-level
Regressions — new features frequently broke existing ones

Takeaway: This demonstrates that AI agents can sustain goal-directed work at massive scale — but also that human-written compilers maintain clear advantages in efficiency and reliability. The scaffolding matters: well-designed tests and clear progress tracking were essential for the agents to make progress.

Working With AI

The Right Mindset

Think of Claude Code as mentoring a chaotic but talented colleague

✅ What Works

Clear instructions — write a CLAUDE.md like an onboarding doc
Review its work — it's brilliant but makes surprising mistakes
Delegate and context-switch — give it a task, go work on something else
Use plan mode — let it think before acting on complex tasks
Play to its strengths — boilerplate, refactoring, tests, exploration

❌ What Doesn't

Watching the terminal — defeats the whole purpose of autonomy
No guardrails — without CLAUDE.md it guesses your conventions
Blind trust — always review before committing
One-shot prompts — iterate, provide feedback, guide it
Expert-level tasks — if you know the domain deeply, you're probably faster

Looking Ahead

The Future Is Agentic

We are witnessing a fundamental shift in how software gets built. The question is no longer "will AI write code?" but "how do we work alongside agents effectively?"

🚀

Agents Get Smarter

Better reasoning, longer context, fewer hallucinations. Each generation closes the gap with human developers.

🤝

Teams of Agents

Multi-agent systems that plan, implement, test, and review — an autonomous software team on demand.

🌐

Universal Tool Access

Open protocols like MCP connect agents to any system. The walled-garden era of AI tools is ending.

The developer role is evolving

From writing every line of code to architecting, reviewing, and orchestrating autonomous agents. The best developers will be those who learn to delegate effectively.

IMPORTANT!

If you actually know a subject well, Claude almost certainly knows it worse than you
Often you can write code MUCH better than it can
Frequently you can also write code faster than it can
But its value is that you can give it a task and switch to something else
Or run two tasks in parallel with two Claudes and switch to something else
Or run four tasks and go eat / go sleep
In most cases Claude doesn't improve the quality or speed of your work — it improves the volume of your work
If you launch it and then just stare at the terminal — you're most likely losing productivity
The one important exception: technologies you know nothing about — here you can save hours to weeks