The inconvenient truth about writing code by hand

Overview

The video argues that writing code by hand is not a “waste of time”, even as agentic engineering (using AI coding agents) becomes more common. While hand-coding is slower, the speaker claims it provides advantages that agents often bypass—especially around learning, correctness, and long-term codebase understanding.

Core technological/product claims and analysis

1) Thought experiment: which engineer would you hire?

The speaker presents three candidates building a Rust + FFmpeg video editor/video player:

• Candidate A (agent-first):

  • Uses agentic tools (mentions Claude Code and Codex)
  • Never writes Rust/FFmpeg integration code by hand

• Candidate B (mixed):

  • Writes Rust by hand
  • Relies on an existing crate for the core video player functionality

• Candidate C (hand-code core):

  • Still uses agents day-to-day
  • Implements the media engine by hand using the FFmpeg sys crate
  • Agents help only when they’re stuck

Conclusion: Candidate C is framed as the best hire because they built a key component manually, gaining hands-on understanding of core concepts needed for future features and debugging.

2) Personal case study: fixing a knowledge gap with FFmpeg

The speaker describes building a media engine via agents that “worked,” but was not correct across many media files—failing in real-world edge cases.

Instead of iterating blindly with agents, they chose to learn FFmpeg by building a simple media pipeline manually, using AI to help but writing the logic by hand.

Result: deeper conceptual understanding → better ability to rebuild/improve the engine and to use agents more effectively later.

3) Main reasons to keep coding by hand (with specific examples)

A) Learning a programming language (still valuable in 2026)

Even though agents can generate code in many languages, the speaker says learning through books + implementing by hand remains beneficial. They use an LLM when they need clarification, but the core learning is manual.

• Example concept: agents often introduce “boolean creep” (adding many booleans instead of modeling state with an enum).
• The speaker’s argument: language learning makes these issues easier to catch during review of agent-generated code.

B) Learning tricky dependencies by hand

Hand-coding dependencies, the speaker claims, helps you understand real constraints and avoids “AI shortest-path” mistakes.

Example: cpal (cross-platform audio)

• Real-time audio must avoid blocking in the real-time audio thread.
• An agent allegedly suggested using a mutex, which can block and cause audio glitches.
• Because the speaker had already prototyped manually, they recognized the correct approach: a real-time ring buffer for synchronization.

Additional dependencies learned by hand (noted as having poor documentation in the subtitles):

• FFmpeg
• GPU I (referred to as “GPU I” in the subtitles)

Agents help bridge documentation gaps, but hand learning creates a “positive feedback loop” for future agent usage.

C) Doing high-level architecture by hand to enable better design

Agents may optimize for producing working code quickly, but can lead to tangled architecture. The speaker suggests doing initial/high-level design manually, then using agents for implementation.

• In Rust, they define traits/types and method/function signatures first.
• They mention using Rust’s unimplemented macro pattern to compile without full implementation, enabling:
  • manual “air-feel” / resistance-checking of design
  • a clear target for the agent to implement missing pieces

Claimed outcome: more consistent cross-platform behavior and easier future feature additions (images, effects, transitions).

D) Codebase comprehension as the biggest long-term problem

The speaker says the future biggest issue is codebase comprehension: people (and even authors) may not fully understand agent-built systems.

Their mitigation strategy:

• Manually implement parts they need to truly understand
• then delegate to agents to extend/refactor using that established mental model

They also note that agent Q&A can help, but may involve hallucinations, so for critical systems they still write by hand:

• payments
• user authentication
• other high-stakes areas

They still like adversarial review (agent-based and/or tool-based) for safety.

E) Personal motivation/joy

Beyond technical reasons, the speaker argues enjoyment matters: coding by hand is mentally stimulating, and “not wasting time” on things you enjoy isn’t “time wasted,” even if industry narratives suggest otherwise.

Sponsored tool / feature: Code Rabbit (review + PR automation)

The video includes a sponsor for Code Rabbit, described as improving code quality and code review for both human-written and agent-written code.

Key features mentioned

• GitHub integration:

  • Automatically reviews PRs targeting the main branch

• Issue detection:

  • errors
  • style improvements
  • security vulnerabilities
  • edge cases (and other common problems)

• Actions / outputs:

  • detailed summaries
  • prompts to send to an agent to fix issues

• “New review UI”:

  • review changes as layered views rather than only a flat diff
  • layer summaries
  • inline review comments
  • optional generated UML sequence diagrams showing interactions (e.g., endpoints/functions and integration paths)

Speaker’s claim

The speaker argues this helps with both security and understanding the codebase.

Main speakers/sources

• Main speaker: the video’s narrator/author (unnamed in subtitles), discussing their Rust/FFmpeg video editor project and arguing for manual coding
• Sponsored source: Code Rabbit (tool for automated PR review and a layered review UI)
• Referenced AI coding agents/tools: Claude Code and Codex
• Referenced libraries/crates:
  • Rust
  • FFmpeg and the ffmpeg-sys crate
  • cpal
  • iced (desktop framework; mentioned via the candidate example)
  • “GPU I” (as cited in the subtitles)