diff --git a/assets/beyond-vibe-coding/log-chat.md b/assets/beyond-vibe-coding/log-chat.md index 0f59507..beddabf 100644 --- a/assets/beyond-vibe-coding/log-chat.md +++ b/assets/beyond-vibe-coding/log-chat.md @@ -598,3 +598,51 @@ Rationale: --- +## 2026-02-01 @writer — Article Split & SEO Optimization + +**Action:** Split article into 3 parts, SEO optimization, credentials expansion + +**Changes made:** + +1. **Created 3 separate files:** + - `text-p1.md` — Intro + Vibe Coding + Spec-Driven Development (~1,400 words) + - `text-p2.md` — AI Pair Programming + Agentic Coding + Ralph Loop (~1,200 words) + - `text-p3.md` — Human-in-the-Loop + TDD + AI + Conclusion (~1,100 words) + +2. **SEO optimizations (Part 1):** + - "vibe coding" in title and first sentence + - "what is vibe coding" question hook in first paragraph + - Series intro added at top + - Cross-links to other parts + +3. **Expanded credentials from spec files:** + - Vibe Coding: Added Collins Dictionary, Wikipedia, arXiv reference + - Spec-Driven: Added Martin Fowler analysis, GitHub Blog official announcement, Tessl registry stats + - Agentic Coding: Added arXiv papers with details (13 observations + 99 surveys), Ralph Loop full timeline, VentureBeat interview, economics ($10.42/hr) + - AI Pair Programming: Added Microsoft Learn docs, Responsible AI practices, Cody by Sourcegraph, Claude Code positioning with output styles + - TDD + AI: Added Kent Beck podcast quote, DORA Report 2025, Google Cloud analysis, 8th Light "Missing Protocol" article + +4. **Moved comics deeper into sections:** + - Before: Comics immediately under H2 headers + - After: Comics after relevant paragraphs in "Henry's thoughts" + - Example: "Karpathy tweet" comic now after "I use it often myself" paragraph + +5. **Inserted user's comment:** + - `[правда я все же использую клавиатуру для этого]` → "though I still use my keyboard for this" + +**Files created:** +- `assets/beyond-vibe-coding/text-p1.md` +- `assets/beyond-vibe-coding/text-p2.md` +- `assets/beyond-vibe-coding/text-p3.md` + +**Pending:** +- HITL comic still TODO (not in CDN yet) +- text.md kept as reference (original monolithic version) + +**Ready for publication:** +- ✅ Part 1: Ready for Feb 2, 2026 (tomorrow!) +- ✅ Part 2: Ready for Feb 6-7 +- ✅ Part 3: Ready for Feb 11-12 (needs HITL comic) + +--- + diff --git a/assets/beyond-vibe-coding/text-p1.md b/assets/beyond-vibe-coding/text-p1.md new file mode 100644 index 0000000..cb30ebe --- /dev/null +++ b/assets/beyond-vibe-coding/text-p1.md @@ -0,0 +1,106 @@ +# What Is Vibe Coding in 2026? One Year From Karpathy's Tweet + +*Part 1 of the "Beyond Vibe Coding" series* + +What is vibe coding in 2026? Exactly one year ago — February 2, 2025 — Andrej Karpathy posted the tweet that started it all. The term became Collins Dictionary's Word of the Year. But here's the thing: what Karpathy meant and what "vibe coding" (or "vibecoding" as some write it) means now are two different things. + +{% embed https://x.com/karpathy/status/1886192184808149383 %} + +When Karpathy first used the term, he meant something specific. You tell the agent what to do and evaluate the result. The key "vibe" is that you don't dig into HOW the code is written. Something doesn't work? Just write the next prompt, and so on. Now "vibe coding" often means any AI-assisted development at all. Though honestly — in many cases, that's exactly how it works. + +We're already seeing derivatives — vibe design, vibe ops, vibe anything. But professional developers need more than vibes. That's where approaches like spec-driven development come in — and that's what this series is about. + +![Comic: Senior developer explains you need to understand code first, junior admits he builds first then figures out structure](https://cdn.banatie.app/blog/henry-devto/img/c0c3ad3d-13ee-4dbf-9f4a-5db3bf64b378) + +But be honest: when you accept the agent's changes without looking, you catch yourself thinking — is this actually done right, can I trust what the LLM generated without reviewing it? When a colleague says they vibe-coded some functionality — do you picture thoughtful architecture or more like "somehow works"? Is vibe coding cheating and irresponsibility, or a perfectly professional approach? + +What I know for certain — AI development is here, whatever we call it. According to Stack Overflow 2024, 76% of developers use or plan to use AI tools. About a third of senior developers — those with 10+ years of experience — generate more than half their code with AI. + +![Infographic: AI adoption among developers - 76% use AI tools, productivity and trust metrics](https://cdn.banatie.app/blog/henry-devto/img/1175042e-1e41-4675-8fb3-25febe7cedea) + +Let's figure out what exactly we can do with AI. Different approaches exist, giving more control at different stages of work. Choosing the right one and applying it consciously — that's the professional approach. In this article, I'll cover vibe coding itself and spec-driven development — my main approach for serious projects. + +--- + +## Vibe Coding: The Entry Point + +**Credentials:** +- Coined by [Andrej Karpathy](https://x.com/karpathy/status/1886192184808149383) (February 2, 2025) +- [Collins Dictionary Word of the Year 2025](https://www.collinsdictionary.com/woty) +- [Wikipedia article](https://en.wikipedia.org/wiki/Vibe_coding) documenting the phenomenon +- Referenced in academic papers: [arXiv 2512.14012](https://arxiv.org/abs/2512.14012) "Professional Software Developers Don't Vibe, They Control" (University of Michigan, December 2025) + +**What it is:** +- Iterative prompting until code works +- No upfront planning, minimal specification +- Trust AI to handle details, fix issues as they appear +- Evaluate results visually or by running the code + +Vibe coding is a great approach. Really. I use it often myself — though I still use my keyboard for this. It works perfectly for non-critical features, dev tools, prototypes, experiments. + +When do I use it? When the result is easy to evaluate visually. When scope is obviously localized to one or a few files. + +Do I look at the diff? Honestly, almost always. But I don't check every line — I quickly assess which files changed, what was added or removed. This lets me catch moments when the AI "went off track" fast. + +Does it produce bad code? Maybe, but there are simple ways to improve quality: describe code style in CLAUDE.md (or AGENTS.md), describe the architecture of the relevant part, provide examples of existing similar features as templates, ask the agent to run typecheck, linter, and prettier when done. + +![Comic: Developer shows Karpathy's vibe coding tweet, colleague says now he can do this officially](https://cdn.banatie.app/blog/henry-devto/img/c4c24f43-d0ac-45d2-84d0-6cb0624a8957) + +On the other hand, there are pitfalls. 27% of companies have banned AI tools at least temporarily over privacy and security concerns. Apple restricted ChatGPT and Copilot. Amazon banned ChatGPT after discovering responses resembling internal data. Samsung had an employee leak confidential information through ChatGPT. + +Be careful with security. Don't use vibe coding on critical infrastructure. Especially where you can't easily roll back changes. + +You might ask — is it even legitimate to use vibe coding at work? Absolutely! First, you save significant energy on simple things. Your brain resources are limited — delegate simple tasks and routine to AI. It'll do it faster, and you can spend your focus on more important stuff. Second, techniques exist beyond vibe coding that significantly improve development quality and reliability. + +So what are these methods? + +--- + +## Spec-Driven Development: Structure First + +**Credentials:** +- Formalized by GitHub Engineering Team: [GitHub Spec Kit](https://github.com/github/spec-kit) (open-source, MIT license, September 2025) +- Official announcement: ["Spec-driven development with AI: Get started with a new open source toolkit"](https://github.blog/ai-and-ml/generative-ai/spec-driven-development-with-ai-get-started-with-a-new-open-source-toolkit/) (GitHub Blog, September 1, 2025) +- Analysis by [Martin Fowler](https://martinfowler.com/articles/exploring-gen-ai/sdd-3-tools.html): "Understanding Spec-Driven Development" +- Featured in [Thoughtworks Technology Radar](https://www.thoughtworks.com/en-us/radar) Volume 33 (November 2025) +- Production tools: [AWS Kiro](https://aws.amazon.com/startups/prompt-library/kiro-project-init) (spec-driven IDE, public preview July 2025), [Tessl Framework](https://tessl.io/blog/tessl-launches-spec-driven-framework-and-registry/) (closed beta, 10,000+ specs in registry) +- Community solutions: [BMAD Method](https://recruit.group.gmo/engineer/jisedai/blog/the-bmad-method-a-framework-for-spec-oriented-ai-driven-development/) (21 specialized agents), [OpenSpec](https://mcpmarket.com/server/openspec) (lightweight CLI, brownfield-first) +- Widely used by: Claude Code users, enterprise teams, GitHub Copilot Workspace + +**How it works:** + +Write detailed specification BEFORE code. Spec includes requirements, architecture, API contracts, error handling, edge cases. AI executes against the spec. The spec becomes living documentation — often saved as `CLAUDE.md` or `.spec` files in project root. + +Human focuses on WHAT. AI handles HOW. + +This is actually my main approach for large projects. Especially when adding a new section or functionality that didn't exist before. Time spent writing spec is often significant. But it gives good control — modern models follow instructions pretty well. You can vary the degree of freedom for the agent: you can specify file and folder names yourself, or just give an outline of the solution. + +After spending half a day on specification, you watch Claude Code finish implementation in 10 minutes. Feels unfair, but the results are solid. + +![Comic: Developer brags AI generated code in 15 minutes, colleague points out he spent 6 hours writing the prompt](https://cdn.banatie.app/blog/henry-devto/img/79c4c6fd-129a-499f-be04-f503eff018b5) + +The spec becomes reference for future work. Months later, a new session starts with "read the spec, find the code" — and the agent has full context immediately. + +**Long-term challenges:** + +To continue development later, you need to keep documentation current. Specs often start drifting from real code even during initial implementation. Details change, paths get renamed during refactoring. Keeping the spec up to date adds cognitive load. My solution: commit spec changes alongside code changes. Treat documentation as part of the codebase. Instruct the AI agent to always update the document after completing any task. + +**Pro tip:** + +Use Claude Desktop for spec development: give it Filesystem MCP for code access, enable web search for current documentation. Brainstorm the solution together with AI, define architecture — and only then ask it to write the spec. + +--- + +## What's Next + +This was Part 1 of the "Beyond Vibe Coding" series. We covered vibe coding itself and spec-driven development — two ends of the planning spectrum. + +In Part 2, we'll explore the autonomy spectrum: AI pair programming (where you stay in the driver's seat) versus agentic coding (where you let the AI run free). Plus the infamous Ralph Loop — 14-hour autonomous coding sessions. + +In Part 3: Human-in-the-Loop patterns and TDD + AI — when you need guardrails and quality guarantees. + +Different approaches for different stakes. Choose consciously. + +--- + +*What's your experience with vibe coding? Do you use specs, or prefer to iterate? Share in the comments — I'm genuinely curious what works for you.* diff --git a/assets/beyond-vibe-coding/text-p2.md b/assets/beyond-vibe-coding/text-p2.md new file mode 100644 index 0000000..a737519 --- /dev/null +++ b/assets/beyond-vibe-coding/text-p2.md @@ -0,0 +1,122 @@ +# AI Pair Programming vs Agentic Coding: Two Extremes of Vibe Coding + +*Part 2 of the "Beyond Vibe Coding" series* + +In [Part 1](/henry-devto/what-is-vibe-coding-in-2026), we covered vibe coding and spec-driven development — two ends of the planning spectrum. Now let's explore the autonomy spectrum: how much control do you give the AI? + +On one end: AI pair programming, where you stay in the driver's seat. On the other: agentic coding, where you set a goal and walk away. Both have their place. Both have their traps. + +--- + +## AI Pair Programming: Working Together + +**Credentials:** +- GitHub official positioning: ["Your AI pair programmer"](https://github.com/features/copilot) (Copilot marketing since 2021) +- [Microsoft Learn documentation](https://learn.microsoft.com/en-us/industry/mobility/architecture/ai-pair-programmer): AI pair programmer architecture +- [GitHub Copilot Fundamentals](https://learn.microsoft.com/en-us/training/paths/copilot/) training on Microsoft Learn +- [Responsible AI practices](https://github.blog/ai-and-ml/github-copilot/responsible-ai-pair-programming-with-github-copilot/) (GitHub Blog) +- Tools: [GitHub Copilot](https://github.com/features/copilot) (Free/Pro $10/Business $19/Enterprise $39), [Cursor](https://cursor.com), [Windsurf](https://www.codeium.com/windsurf), [Tabnine](https://www.tabnine.com), [AWS CodeWhisperer](https://aws.amazon.com/codewhisperer), [Cody by Sourcegraph](https://sourcegraph.com/cody) +- Claude Code positioning: ["Your AI Pair Programming Assistant"](https://claudecode.org) with [output styles for pair programming](https://shipyard.build/blog/claude-code-output-styles-pair-programming/) (September 2025) +- 720 monthly searches for "ai pair programming" + +**The promise:** + +AI as collaborative partner, not just autocomplete. Continuous suggestions while coding. Context-aware completions. Real-time feedback and alternatives. More than tab-completion — understanding project context. + +**My honest experience:** + +I've tried AI autocomplete multiple times. Each time, I ended up disabling it completely. + +Why? When I'm writing code, I've already mentally worked out what I want. AI suggesting my next line just interrupts my thought process. Standard IDE completions always worked fine for me. + +I know many developers love it. Just doesn't fit my workflow. + +![Comic: Developer tries to type simple code while AI bombards with irrelevant suggestions](https://cdn.banatie.app/blog/henry-devto/img/8bea3b16-f764-4212-8c09-918b87668884) + +**Where I find real pair programming:** + +Claude Desktop with good system instructions plus Filesystem MCP to read actual project files. That's when I feel like I'm working WITH someone who understands my problem and actually helps solve it. + +Autocomplete is reactive. Real pair programming is proactive — discussion, exploration, questioning assumptions. + +**The productivity numbers:** + +GitHub claims 56% faster task completion with AI assistants. Their study shows Copilot users complete 126% more projects per week. Sounds great. + +But here's counter-evidence: METR study found experienced open-source developers took 19% LONGER to complete tasks when using AI tools. Completely contradicts the marketing. + +The truth probably depends on context. AI effectiveness varies wildly by task type, developer skill with AI tools, and workflow fit. Not universally faster, not universally slower. + +--- + +## Agentic Coding: High Autonomy + +**Credentials:** +- Academic research: [arXiv 2508.11126](https://arxiv.org/abs/2508.11126) "AI Agentic Programming: A Survey of Techniques" (UC San Diego, Carnegie Mellon, August 2025) — comprehensive taxonomy of agent systems +- [arXiv 2512.14012](https://arxiv.org/abs/2512.14012) "Professional Software Developers Don't Vibe, They Control" (University of Michigan, December 2025) — 13 observations + 99 developer surveys showing professionals use agents in controlled mode with plan files and tight feedback loops +- Tools: [Claude Code](https://claude.ai/code), [Cursor 2.0 Composer](https://cursor.com/blog/2-0) (October 2025, up to 8 parallel agents, Git worktrees isolation), [GitHub Copilot Agent Mode](https://github.blog/ai-and-ml/github-copilot/agent-mode-101-all-about-github-copilots-powerful-mode/) (preview February 2025), [Copilot Coding Agent](https://github.blog/ai-and-ml/github-copilot/from-idea-to-pr-a-guide-to-github-copilots-agentic-workflows/) (asynchronous, July 2025) +- [Cursor Scaling Agents](https://cursor.com/blog/scaling-agents) (January 2026): long-running autonomous coding +- Open-source: [Agentic Coding Framework](https://github.com/DafnckStudio/Agentic-Coding-Framework) on GitHub + +**What it is:** + +Agent operates with high autonomy. Human sets high-level goals, agent figures out implementation. Agent can plan, execute, debug, iterate without constant approval. + +Different from vibe coding: agentic coding is systematic. Agent creates a plan, executes it methodically, can course-correct. Vibe coding is reactive prompting without structure. + +My take? Skeptical so far. + +I'd like to believe in this approach. The idea of extended autonomous sessions sounds amazing. But here's my question: what tasks justify that much autonomous work? + +Writing a detailed spec takes me longer than executing it. If Claude Code finishes in 10 minutes after I've spent hours on specification, why would I need 14 hours of autonomy? + +I'm skeptical about applications in my projects. Maybe it works for certain domains — large refactors, extensive testing, documentation generation across huge codebases? But even then, I can't imagine Claude Code not handling it in an hour. + +![Comic: Builder gives autonomous androids task to build playground, they overengineer into theme park](https://cdn.banatie.app/blog/henry-devto/img/031320e3-9252-4c6a-9c98-e08d7ef40855) + +**The Ralph Loop extreme:** + +Named after Ralph Wiggum from The Simpsons. The concept: give the agent a task, walk away, return to finished work. + +- **Creator**: Geoffrey Huntley ([ghuntley.com/ralph](https://ghuntley.com/ralph/)) +- **Timeline**: First discovery February 2024 → Public launch May 2025 → [Viral wave January 2026](https://venturebeat.com/technology/how-ralph-wiggum-went-from-the-simpsons-to-the-biggest-name-in-ai-right-now) (VentureBeat: "How Ralph Wiggum went from 'The Simpsons' to the biggest name in AI") +- **Interviews**: [Dev Interrupted Podcast](https://devinterrupted.substack.com/p/inventing-the-ralph-wiggum-loop-creator) (January 12, 2026), [LinearB Blog](https://linearb.io/blog/ralph-loop-agentic-engineering-geoffrey-huntley) +- **Official plugin**: [ralph-wiggum.ai](https://ralph-wiggum.ai) from Anthropic (Boris Cherny) +- **Economics**: $10.42/hour with Claude Sonnet 4.5 (per Huntley's data) +- **Case studies**: cloning HashiCorp Nomad, Tailscale — days instead of years + +The loop is elegantly simple: `while :; do cat PROMPT.md | agent; done` — fresh context each iteration, progress tracked in Git. Huntley reported 14-hour autonomous sessions. + +If you've found great applications for Ralph Loop, I'm genuinely curious. Share your wins in the comments. + +**The permissions reality:** + +Agentic coding hits a wall in practice: permissions. Claude Code asks approval for every file write, API call, terminal command. Completely breaks flow. Kills the autonomy promise. + +My workarounds: I ask Claude to add all MCP tools to `.claude/settings.json` proactively — that reduces interruptions. Sometimes I run with `--dangerously-skip-permissions`, but keep an eye on what's happening. + +Try to set up your environment so the agent can't do anything that git reset couldn't fix. This is clearly a problem waiting for a solution. We need better ways to control coding agent actions. + +--- + +## Vibe Coding vs Agentic Coding: The Difference + +People often confuse these. Here's how I see it: + +**Vibe coding**: reactive. Prompt → result → prompt → result. No plan, no structure, just vibes. + +**Agentic coding**: systematic. Goal → plan → execute → validate → iterate. Structure exists, AI manages it. + +Both can produce working code. The difference is predictability. Agentic coding with a good spec gives you reproducible results. Vibe coding gives you... vibes. + +--- + +## What's Next + +In Part 3, we'll cover the guardrails: Human-in-the-Loop patterns (strategic checkpoints, not endless permissions) and TDD + AI (tests as specification, quality first). + +When stakes are high, vibes aren't enough. You need structure that catches mistakes before they ship. + +--- + +*Do you use agentic coding? Have you tried Ralph Loop? I'm skeptical but curious — what applications actually work? Share in the comments.* diff --git a/assets/beyond-vibe-coding/text-p3.md b/assets/beyond-vibe-coding/text-p3.md new file mode 100644 index 0000000..598b112 --- /dev/null +++ b/assets/beyond-vibe-coding/text-p3.md @@ -0,0 +1,110 @@ +# Human-in-the-Loop and TDD + AI: When Quality Matters + +*Part 3 of the "Beyond Vibe Coding" series* + +In [Part 1](/henry-devto/what-is-vibe-coding-in-2026), we covered vibe coding and spec-driven development. In [Part 2](/henry-devto/ai-pair-programming-vs-agentic-coding), we explored the autonomy spectrum from pair programming to Ralph Loop. + +Now let's talk about guardrails. When stakes are high, vibes aren't enough. You need structure that catches mistakes before they ship. + +--- + +## Human-in-the-Loop: Strategic Checkpoints + +**Credentials:** +- Atlassian Research: HULA framework (Human-Understanding Large Language Model Agents) +- Formalized in ICSE 2025 paper ([arXiv 2411.12924](https://arxiv.org/abs/2411.12924)) +- [Google Cloud AI documentation](https://cloud.google.com/discover/what-is-human-in-the-loop-machine-learning) on HITL patterns +- Implemented in: Claude Code Planning Mode, Cursor Composer approval flows + +**What it is:** + +AI operates autonomously BETWEEN checkpoints. Human approves key decisions, reviews output at strategic moments. Not constant supervision — strategic oversight. + +Agent proposes approach, human confirms direction. Then agent executes freely until next checkpoint. + +**Permissions ≠ HITL:** + +Don't confuse permissions with Human-in-the-Loop. Permissions are too low-level. "Can I write this file?" tells me nothing about what task the agent is actually solving. + +Real HITL is Planning Mode. Agent shows the plan: "here's what I'll do, these files will change, here's the expected outcome." That's decision-level control. + +The problem with current agents: they don't understand WHEN to stop and ask. Rarely hit the right moment. Either too much autonomy (goes off track) or too many interruptions (breaks flow). + +[TODO: HITL comic — robots discussing getting rid of the human, final panel shows human among circle of robots passing boxes] + +Future improvement area: agents that know when they're uncertain and should consult the human. Like "I don't know" responses — current models aren't great at this in practice. + +**When to use:** + +Production code with moderate complexity. When outcome matters but speed also matters. Team environments where others will review anyway. Learning new approaches where you want to see the agent's reasoning. + +Medium stakes: not prototype territory (vibe coding works there), not critical infrastructure (TDD territory). + +--- + +## TDD + AI: Quality First + +**Credentials:** +- Official name: "AI-aided test-first development" — [Thoughtworks Technology Radar](https://www.thoughtworks.com/en-us/radar/techniques/ai-aided-test-first-development) (April 2023, status: TRIAL) +- [DORA Report 2025](https://dora.dev/research/2025/dora-report/) (Google Cloud): "AI is an amplifier, not a fix" — organizations with strong testing practices get more benefit from AI +- [Google Cloud analysis](https://cloud.google.com/discover/how-test-driven-development-amplifies-ai-success) (January 2026): "How TDD Amplifies AI Success" +- Kent Beck (creator of TDD): [Pragmatic Engineer Podcast](https://newsletter.pragmaticengineer.com/p/tdd-ai-agents-and-coding-with-kent) (June 2025) — "TDD is a superpower when working with AI. I communicate things the Genie missed in terms of tests" +- [8th Light](https://8thlight.com/insights/tdd-effective-ai-collaboration): "TDD: The Missing Protocol for Effective AI Collaboration" (July 2025) +- [Builder.io guide](https://www.builder.io/blog/test-driven-development-ai): "AI turns TDD's weaknesses into strengths" (August 2025) +- Tools: [Qodo](https://www.qodo.ai/blog/ai-code-assistants-test-driven-development/) (AI test generation), Claude Code, Cursor + +**How it works:** + +Write tests BEFORE implementation (classic TDD). AI generates code to pass tests. Tests become executable specification. + +Red → Green → Refactor cycle, but AI handles implementation. Tests catch AI mistakes automatically. Tests provide verification without human review of every line. + +**Tests as specification:** + +Tests are absolutely critical for key functionality. I always instruct agents to run tests. + +But here's the thing: writing comprehensive tests upfront plus detailed spec — that's already 80% of the work. If you've written that much structure, is AI really saving time? + +Most valuable when you have existing spec that naturally converts to tests — like API documentation. Then yes, tests-first makes perfect sense. + +![Comic: Developer writes tests to verify AI agent code using another AI agent](https://cdn.banatie.app/blog/henry-devto/img/94559d7c-06ab-4e5f-860a-87419906f3b5) + +**The guardrails approach:** + +Tests become safety boundaries for the agent. Agent can iterate freely within test constraints. No need to review every implementation detail. Just verify: tests pass, coverage maintained. + +Especially valuable for agentic coding. Let the AI experiment, tests catch the mistakes. + +**Critical warning:** + +AI-written tests need human review. I've seen agents write "passing" tests using mocked requests — test passes, code is broken. The test verified syntax, not behavior. + +Correct tests = solid foundation. Bad tests = false confidence that destroys future work. + +Review test logic before trusting it. Make sure tests verify actual behavior, not just that code runs. + +--- + +## Conclusion + +What I typically use: +- Dev tools and experiments: vibe coding works fine. +- Production features: spec-driven with Planning Mode. +- Critical systems: TDD plus extensive review. +- Research and exploration: Claude Desktop as true pair programmer. + +The pattern? Higher stakes → more structure. Lower stakes → more vibes. + +Your approach might be different. If you do things differently — different tools, different approaches, different combinations — share your wins in the comments. What works for you as an engineer? + +--- + +## The Full Series + +- **Part 1**: [What Is Vibe Coding in 2026?](/henry-devto/what-is-vibe-coding-in-2026) — vibe coding + spec-driven development +- **Part 2**: [AI Pair Programming vs Agentic Coding](/henry-devto/ai-pair-programming-vs-agentic-coding) — the autonomy spectrum +- **Part 3**: Human-in-the-Loop and TDD + AI — guardrails and quality (you are here) + +--- + +*What's your approach? Pure vibes, full TDD, or something in between? I'm curious what actually works in your projects.*