It’s Time to Completely Abandon Old-School Programming

Six months of hands-on experience with AI programming

Leo · 2026

Six Months, Zero Handwritten Code

0

Lines of handwritten code

1/10

Time required

100%

AI-generated

Voice rooms · Prediction backend · Lambda → Beanstalk migration · CI · Documentation · Internal tools

Redefining the Engineer’s Role

From "Writing Code" to "Providing Context"

When progress stalls, the solution is never "just try harder"
Instead, take a step back and ask: what is the Agent still missing?
Context · Tools · Constraints

The quality of context engineering = the quality of AI output

The more precise you write, the less AI goes off track; the vaguer you write, the more rework you get

The Engineer’s Role Is Changing

Before

Write code line by line
Debug manually
Review manually
Rely on memory for documentation

Now

Design tasks and define constraints
Agent writes code + self-tests
Agent cross-reviews
Humans intervene only at merge time

From code author → AI context engineer

Using Agents to Review Agents

Codex Automated Review

The volume of AI-generated code is too large, and purely manual review inevitably misses things

Scheduled daily scans of all frequently developed team repositories have indeed uncovered quite a few hidden bugs

Make Applications Readable to Agents

Agent Autonomous Verification Workflow

The bottleneck has shifted from "writing code" to manual QA—let Agents directly read the UI, logs, and monitoring

sequenceDiagram
    participant C as Agent
    participant A as Application
    participant D as Chrome DevTools

    C->>D: Select target page + clear console
    C->>D: Capture pre-action snapshot
    C->>A: Trigger UI interaction path
    A-->>D: Runtime events
    C->>D: Capture post-action snapshot
    C->>A: Apply fix + restart

    loop Repeat until passing
        C->>D: Re-run verification
    end

Turn the Repository into the Single Source of Knowledge

Give the Agent a Map, Not a Manual

Context is a scarce resource — huge instruction files crowd out what actually matters
If everything is "important," then nothing is important — with too much information, the Agent only does nearest-pattern matching
Large files rot extremely fast — a graveyard of outdated rules that becomes a breeding ground for bugs once people stop maintaining them
Impossible to validate automatically — coverage, freshness, and ownership all spiral out of control

AGENTS.md ≈ a 100-line table of contents → points to the real documentation under docs/

From MCP to Skill

Method Matters More Than Connection

MCP vs Skill

MCP solves "connection"

The Agent can call YApi APIs ✅
The Agent can check ZenTao bugs ✅
But it doesn’t know that after changing a field it should sync the docs ❌
It doesn’t know it should add Chinese comments and enum descriptions ❌

MCP gives the Agent plumbing
Skill teaches the Agent how to use water

::right::

Skill solves "method"

After changing code → sync docs automatically
Every field → Chinese comments + enum descriptions
Fill in request/response examples
Validate consistency between docs and code

Advantages of Skill:

Carries methodology, not just connections
Version-managed and reviewable
Loaded on demand, without consuming context

ZenTao Skill: Fix a Bug by Pasting a Link

No need to think about how to write the prompt—just paste the bug ticket URL to the Agent

Help me install this skill: https://github.com/leeguooooo/zentao-mcp

YApi Skill: Automating Upstream/Downstream Integration

sequenceDiagram
    participant PM as Upstream party
    participant Dev as Developer
    participant Agent as Agent
    participant YApi as YApi

    PM->>Dev: Send integration request + YApi endpoint URL
    Dev->>Agent: Paste the endpoint URL
    Agent->>YApi: Read interface definition via Skill
    Agent->>YApi: Automatically navigate to related interfaces
    Agent->>Agent: Understand full context and generate integration code
    Agent->>Dev: Output implementation + automatically update local docs
    Dev->>YApi: `yapi docs-sync` syncs the docs

After Bian Sang got the API URL, he completed the entire broadcast system integration in less than a day

Project-Level Skill Composition: Fully Automated Bug Investigation

flowchart LR
    A[ZenTao Bug] -->|ZenTao Skill| B[Read bug details]
    B --> C[Locate relevant code]
    C -->|Log Skill| D[Query runtime logs]
    C -->|DB Skill| E[Query database]
    C -->|KV Skill| F[Query cache]
    C -->|Token Skill| G[Verify authentication]
    D & E & F & G --> H[Analyze root cause]
    H --> I[Fix code and submit]

The Agent can not only understand bug descriptions and locate code
but also connect directly to the test environment and pull real data to analyze the issue

Open Source Recommendation: Superpowers

An Agent Skill Framework with 100k+ Stars

Superpowers: A Complete Development Workflow

1

Brainstorming
Think it through before acting, with Socratic questioning

2

Writing Plans
Break work into 2–5 minute tasks

3

Git Worktrees
Isolated development environments, zero risk

4

Test-Driven Dev
Enforced TDD: write tests before code

5

Subagent Dev
Multiple Agents in parallel + two review rounds

6

Parallel Agents
Automatically parallelize independent tasks

7

Systematic Debug
Four-stage troubleshooting, no speculative fixes

8

Verification
Verification required before completion; evidence before conclusions

9

Code Review
Bidirectional review, no blind agreement

10

Finishing Branch
End-of-work decision: merge / PR / keep / abandon

Key Feature: Everything Triggers Automatically

🚫

No need to manually remind the Agent to write tests

🚫

No need to manually remind the Agent to think first before acting

🚫

No need to manually remind the Agent to verify results

🚫

No need to manually remind the Agent to do Code Review

Turn good engineering practices from "relying on self-discipline" into "relying on the system"

Subagent Parallel Development Workflow

flowchart TD
    P[Implementation plan] --> S1[Subagent 1: Task A]
    P --> S2[Subagent 2: Task B]
    P --> S3[Subagent 3: Task C]
    S1 --> R1[Review: spec compliance]
    S2 --> R2[Review: spec compliance]
    S3 --> R3[Review: spec compliance]
    R1 --> Q1[Review: code quality]
    R2 --> Q2[Review: code quality]
    R3 --> Q3[Review: code quality]
    Q1 & Q2 & Q3 --> M[Merge integration]

Each sub-Agent has isolated context · Two review rounds · Can work autonomously for hours at a time

Pitfall Guide

The Easiest Mistakes to Make with AI Programming

Seven Major Pitfalls

Pitfall 1 If you don’t hold the line at the start, everything later becomes debt — AI amplifies direction; it does not correct it

Pitfall 2 Context drift — after 20–30 rounds, the Agent starts contradicting earlier decisions

Pitfall 3 Blind trust in "done" — able to run ≠ runs well; happy path ≠ production-ready

Pitfall 4 Not checking the git diff — while fixing one bug, AI may quietly change another field

Pitfall 5 Overcomplicated Agent architectures — flashy multi-role orchestration that becomes a mess in practice

Pitfall 6 Team alignment is hard — one person can make it work, but collaborative workflows must be versioned

Pitfall 7 Abusing LLMs — use deterministic code for deterministic operations; don’t call a model for everything

The Two Most Important Habits

📋

Check the diff before submitting

More important than any Skill

🔄

Start a new conversation for major features

Avoid context drift

Summary

From "Writing Code" to "Designing Systems"

AI programming is not about helping you write code faster, but about making it unnecessary for you to write code at all

🗺️

Design context

Use `AGENTS.md` and Skills to tell the Agent what it should know and what it should do

🛡️

Design constraints

Use standards, tests, and review processes to bound the Agent’s behavioral limits

✅

Design verification

Make the Agent’s output reviewable and verifiable by both humans and other Agents

Do it well →

An engineering team operating efficiently 24/7

Do it poorly →

An exquisitely engineered garbage machine

Fast output, even faster rework

Technology is accelerating, but the essence of engineering has not changed

Clear requirements · Clean architecture · Rigorous verification

These mattered in the era of handwritten code, and they matter even more in the era of AI-written code

Thank You

ZenTao Skill → github.com/leeguooooo/zentao-mcp

Superpowers → github.com/obra/superpowers

Q & A