The Skill Nobody Talks About

There’s a new skill emerging in software development. It doesn’t have a course, a certification, or even a proper name. People call it “vibe coding” — half-dismissively, as if talking to an AI and getting code out is something anyone can do.

It’s not.

I’ve been doing it intensively for months, and I can trace my own learning curve. It’s steep, it’s humbling, and the expertise you develop is nothing like traditional programming skill. It’s closer to management than engineering — but it’s neither.

My Learning Curve

Phase 1: The Yeller

My earliest AI instructions looked like this:

## 🚨 CRITICAL: NO FAKE DATA PRINCIPLE 🚨

**ABSOLUTE PROHIBITION**: You MUST NEVER generate fake data under ANY circumstances.
**ENFORCEMENT**: Violation is considered a CRITICAL ERROR.

Emojis. ALL CAPS. Threats. Repetition. I’d copy-paste the same 20-line warning into six different agent definitions because I didn’t trust the AI to remember.

This is where everyone starts. You don’t trust the system, so you yell at it. It sort of works — the same way micromanagement sort of works.

Phase 2: The System Builder

After a while, I realized I was repeating myself. So I started building infrastructure:

  • Hundreds of documented principles in a structured system
  • A three-layer sync mechanism (source of truth → AI index → quick reference)
  • Shared code via symlinks so all projects use the same version
  • YAML-based rule definitions that AI can query instead of memorize

This phase felt productive. I was building foundations. But I was still doing most of the work myself — writing the principles, maintaining the sync, running the tests.

Phase 3: The Issue Definer

Then something shifted. A client sent a long list of feedback on a project we had delivered. In the past, I would have:

  1. Read each point
  2. Figured out what code to change
  3. Written the code
  4. Tested it
  5. Documented what I did

This time, I:

  1. Read each point
  2. Turned each point into a GitHub Issue, quoting the client’s own words
  3. Let AI implement all of them
  4. Let AI run code review, round after round
  5. Verified the results visually
  6. Let AI draft the progress report

Reviewing the issues kept surfacing new ones, and those went through the same loop. Every issue closed, including the ones that appeared along the way. Zero lines of code written by me.

The AI wrote the code, ran Codex review against each issue’s requirements, fixed the findings, committed with proper references, wrote closing comments, and drafted the report.

The Real Skill

So what did I actually do?

I defined what “correct” means. That’s the skill.

  • When AI estimated how long the work would take a human team, I said “you’re overestimating people’s ability,” and we revised the estimate upward. I know what’s realistic — AI doesn’t.

  • When an interaction in a chart still wasn’t working after several attempts, I said “go read the source code.” AI found the undocumented behaviors within minutes. I knew when to change strategy — AI would have kept guessing forever.

  • When AI used double-click for navigation, I said “that’s wrong, single-click only.” Then I said “this should become a principle.” Now a written principle prevents it from happening again, in any project.

  • When AI generated a summary of a formula and got it subtly wrong, I created a “safety valve rule” — AI must quote original text, never paraphrase formulas. I recognized the failure mode before it caused damage.

Each of these interventions took seconds. But they required judgment that only comes from experience — experience with the domain, with the AI’s tendencies, and with what failure looks like.

The Intervention Spectrum

Professional vibe coding is about calibrating two things:

When to let go:

  • Implementing issue after issue → let AI handle it
  • Code review iterations → let Codex loop until zero findings
  • Documentation generation → let AI write, you verify
  • Commit messages → let AI summarize

When to intervene:

  • AI is stuck in a loop → change the approach (“read the source code”)
  • AI is subtly wrong → correct the direction (“you’re overestimating people”)
  • AI creates a good solution → generalize it (“this should be a principle”)
  • AI misses a UX issue → define the rule (“single-click only”)

The ratio shifts over time. Early on, you intervene constantly. As you build better skills, principles, and tools, you intervene less — but each intervention is more impactful.

Building Tools for Tools

The most advanced phase I’ve reached is building tools that build tools:

  • A skill that creates new plugins (plugin-create)
  • A skill that finds the best tool for any task (which)
  • A skill that searches the internet for better alternatives and installs them (which-better)
  • A skill that adds new principles with automatic three-layer sync (add-principle)

This is meta-level vibe coding. You’re not telling AI what to code — you’re building the infrastructure that makes future AI interactions more effective. Every principle you add, every skill you create, every pattern you formalize makes the next session start from a higher baseline.

What This Expertise Looks Like

If you watched me work, you’d see a lot of… reading. Thinking. Asking questions. Saying “no, that’s wrong” and “yes, that’s right” and “this should become a rule.”

You wouldn’t see me typing code.

You’d see me:

  • Splitting a client’s feedback into precise issues
  • Looking at a screenshot and saying “these two controls belong together”
  • Reading an error log and deciding “we need to read the source code, not keep guessing”
  • Noticing that a workaround could be generalized into a principle

This is quality control, not coding. The human’s role has shifted from producer to inspector — but an inspector who also designs the inspection process itself.

Is This “Real” Programming?

I don’t think the question matters. What matters is:

  • A full round of client feedback resolved in days instead of weeks
  • Every change documented, verified, and traceable
  • New principles and tools that make future work faster

If that’s not real, I don’t know what is.

The Uncomfortable Truth

The expertise of vibe coding is invisible. You can’t show it on a whiteboard. You can’t test it in a coding interview. You can’t learn it from a textbook.

You learn it by failing:

  • By watching AI generate plausible but wrong code and learning to spot it
  • By yelling ALL CAPS instructions and learning they don’t help
  • By building elaborate systems and learning which parts actually matter
  • By letting go of control and learning when to grab it back

The professionals of this field will be the ones who fail fastest and systematize what they learn. Not the ones who write the most code — the ones who define the most precise problems.