Everything Is Awesome (And Also Just Programming)

Remember Emmet from The LEGO Movie? Regular construction worker. Follows the instructions. Does everything by the book. Then he discovers he's supposed to be a "Master Builder"—someone who can create anything just by imagining it.

His crisis is immediate: "I can't do this. I only know how to follow the instructions."

That's every developer I talk to about Claude Skills.

"This can't be real programming. Where are the semicolons? Where's the compiler? Where's the 'right way' to do this? I just... write what I want in English and it happens?"

Yes. Welcome to natural language programming v1. It's just LEGO blocks. Stop overthinking it.

The Instruction Manual Trap

In The LEGO Movie, Lord Business is obsessed with order. Everyone must follow the instructions. Build exactly what the manual says. Don't improvise. Don't experiment. The "right way" is the only way.

Sound familiar?

Don't get me wrong—those fundamentals matter. Understanding how code actually works is valuable. But here's the uncomfortable question:

"What if the instruction manual was optional?"

Master Builders Don't Use Manuals (They Use Intent)

The Master Builders in the movie don't flip through instruction booklets. They see LEGO bricks and know what they can build. A pirate ship becomes a robot becomes a submarine—all from the same pieces.

They're not doing magic. They understand the building blocks. They just express their intent differently.

That's exactly what Claude Skills are.

import subprocess
import sys
from datetime import datetime

def git_commit(message: str) -> None:
    """Commit changes with proper error handling"""
    try:
        # Check git status
        status = subprocess.run(
            ['git', 'status', '--porcelain'],
            capture_output=True,
            text=True,
            check=True
        )

        if not status.stdout.strip():
            print("No changes to commit")
            return

        # Stage changes
        subprocess.run(['git', 'add', '.'], check=True)

        # Create commit message
        commit_msg = f"""{message}

🤖 Generated with Claude Code
Co-Authored-By: Claude <noreply@anthropic.com>
"""

        # Commit
        subprocess.run(
            ['git', 'commit', '-m', commit_msg],
            check=True
        )

    except subprocess.CalledProcessError as e:
        print(f"Git error: {e}", file=sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    git_commit("Add new feature")

When user asks to create a commit:
1. Run git status to see changes
2. Draft commit message from git diff
3. Stage relevant files with git add
4. Execute commit with co-author attribution
5. Run git status to verify success

Both accomplish the same thing. One requires 10 years of programming experience. The other requires knowing what you want to accomplish.

Skills aren't replacing programming. They're just a better interface to the same tools.

The Rube Goldberg Callback: Don't Build a Mouse Trap

In my Rube Goldberg automation blog, I talked about how we build absurdly complicated contraptions when a simple solution would work better.

Traditional programming education is the same trap.

You want to accomplish: "Commit my changes with a descriptive message."

Both get the job done. One is a Rube Goldberg machine. The other is a Master Builder solution.

"But Is It Real Programming?"

This is the Lord Business question. "Are you following the approved instructions? Are you doing it the 'right' way?"

Here's the answer: Yes. Skills are programming.

The only difference? The syntax is readable by humans without a CS degree.

That's not a bug. That's a feature.

The Double-Decker Couch Moment

Near the end of The LEGO Movie, Emmet builds the "double-decker couch." Everyone mocks it. It's stupid. It's pointless. It breaks all the rules of furniture design.

Then it saves everyone's life because it was exactly what was needed in that moment.

Your first Claude Skill will feel like a double-decker couch.

But then it's 11 PM. You need to ship a feature. You don't remember git rebase syntax. Your brain is fried.

And that "stupid" five-sentence skill:

• Commits your code
• Follows your repo's commit message conventions
• Adds co-author attribution
• Verifies success
• Works every single time

It worked. That's all that matters.

"Everything Is Awesome" (When You're Part of a Team)

The LEGO Movie's message isn't "throw away the instructions." It's "the instructions are a starting point, not a prison."

Emmet doesn't become a Master Builder by rejecting his construction worker background. He becomes one by combining structured thinking with creative freedom.

Same with natural language programming.

The future isn't "AI replaces programmers." It's "programmers have better tools."

Just like Master Builders still use LEGO bricks—they just build faster and more creatively.

The Kragle Problem (Or: Stop Gluing Your Code to One Paradigm)

In the movie, Lord Business wants to use "The Kragle" (Krazy Glue) to permanently fix everything in place. No more creativity. No more change. Just frozen perfection.

The programming world has its own Kragle: "This is how we've always done it."

Every generation of programmers thinks their way is the "real" way. And every generation is wrong.

Programming is about solving problems. The syntax is just the interface.

How to Actually Use Skills (Without Overthinking It)

Alright, enough philosophy. Let's build something.

When user asks to create a pull request:

1. Run git log and git diff to understand changes
2. Draft a PR summary with:
   - 1-3 bullet point summary of what changed
   - Test plan checklist
   - Co-author attribution
3. Push current branch to remote with -u flag if needed
4. Create PR using gh pr create with the drafted content
5. Return the PR URL

Congratulations. You just programmed in natural language.

The "Get Over It" Manifesto

Some developers are having an identity crisis: "If I can program in English, am I still a programmer?"

Yes.

Just like Master Builders are still building LEGO—they're just not slavishly following someone else's instruction manual.

If that threatens your identity as a "real programmer," ask yourself: Are you gatekeeping because you spent years learning syntax, and it feels unfair that others can skip that step?

Because that's the same argument assembly programmers made about C. C programmers made about Python. And PHP developers made about... okay, bad example.

Every abstraction layer feels like "cheating" until it becomes the new normal.

Everything IS Awesome (When You're Living Your Dream)

The LEGO Movie ends with Emmet realizing he is a Master Builder—not because he learned to ignore instructions, but because he learned to build with intention.

He combined his structured construction worker mindset with creative freedom. He became better than the pure "instruction followers" AND better than the chaotic "build whatever" crowd.

That's the future of programming.

You can be that developer today. Or you can wait 5 years and watch everyone else build LEGO spaceships while you're still reading the instruction manual.

So... Everything Is Awesome?

Look, I'm not going to pretend natural language programming is perfect. It's v1. There are rough edges. Ambiguity issues. Performance limitations. Security considerations.

But here's what's awesome:

• You can build useful tools today without writing 100 lines of boilerplate
• Junior developers can contribute meaningful automation on day one
• Experienced developers can move faster because they're not context-switching between "thinking" and "syntax"
• Non-programmers can finally automate their own workflows instead of waiting for IT
• We can focus on what to build instead of how to appease the compiler

That's pretty awesome.

Next time you open Claude Code and think "I should write a Python script for this," ask yourself:

"What if I just described what I want to happen?"

Try it. Write the skill. See if it works.

If it does? Congratulations. You just became a Master Builder.

Everything is awesome when you're part of a team. 🎵