The Grumpy Senior is the best teacher you ever had. Now build one!

Every profession has that character. The one who made you feel, at least once, like you had no idea what you were doing.

For developers, it's the senior who looks at your pull request and asks, without a trace of diplomacy, whether you actually tested this before submitting it. For writers, it's the editor who hands your draft back covered in red with a note that says "start over." For designers, it's the creative director who lets you present your concept, waits for you to finish, and then asks why you made every colour choice as though you'd never encountered colour theory.

You didn't enjoy it at the time. But that's the person whose voice you still hear when you're about to ship something sloppy.

That character doesn't exist in your AI workflow. Not by default, anyway.

The person who made you rewrite it

The Grumpy Senior isn't grumpy for sport. They're grumpy because they've seen what happens when nobody pushes back. They've watched confident people ship half-formed work. They've inherited codebases that made no sense, campaigns that missed the point entirely, brands that looked like ransom notes. The friction they create isn't hostility. It's the byproduct of experience that cost them something.

That friction is also, if you're honest about it, where most of your real growth happened.

Not in the sessions where everything flowed. In the ones where someone who knew more than you refused to let something bad through.

I've had a few of these people in my career. A senior developer who had zero patience for code that worked but wasn't defensible. An account director who would return a client brief with one comment: "What's the actual idea here?" I didn't love those moments. I'm genuinely grateful for them now. They gave me a standard I carry into everything I build.

AI is extraordinary at a lot of things. Replicating that character isn't one of them. 

Juniors agree with you. Seniors push back.

Capability and experience aren't the same thing, and the gap between them is exactly where the Grumpy Senior lives.

A junior on your team will execute well, work fast, and try hard to give you what you asked for. What they won't do, at least not reliably, is tell you that what you asked for is the wrong thing. They don't yet have the context for that. They haven't been burned enough times. The scar tissue that turns a capable person into someone whose pushback is worth listening to comes from years of seeing what goes wrong and why. 

AI is a junior. A brilliant, tireless, infinitely patient junior who has read everything and experienced nothing.

Models are trained on responses that humans rate positively, and agreeable responses score well. The result is a collaborator that defaults to affirmation, finds the merit in your approach before it looks for the gaps, and tells you "that's a solid direction" when what you actually need is someone asking uncomfortable questions.

When you're in a productive groove with an AI, everything feels like it's holding. But sometimes you're moving fast in the wrong direction and nothing in the conversation is slowing you down.

Meet the Grumpy Dev

My friend Mitch Schwartz built something that changed how I think about this.

He created a Claude Project Skill he calls the Grumpy Code Review. The premise is simple: instead of a helpful, encouraging code reviewer, you get a senior developer with 20 years of experience, no patience for preventable problems, and a specific mandate to find what's wrong. The skill ranks issues by severity, quotes your offending code back at you, and explains exactly why it's a problem and what the fix looks like.

The first time I ran my own code through it, I got back a review that was uncomfortable to read. Not because it was harsh. Because it was accurate.

That's what the skill gave me that a standard AI session doesn't: a second voice in the process that isn't trying to keep things pleasant. One that sounds, honestly, a lot like the senior developers who made me rewrite things ten years ago.

The skill works because it's specific. A defined role with real stakes. A mandate to find problems rather than improve things. An output format that forces specificity. Vague feedback is easy to dismiss. Severity rankings and quoted examples with explanations are not.

Build your own opposing counsel

I think I always have great ideas. I've also learned, the hard way and the expensive way, that I need a lot of rejection between the idea and the thing I actually ship. The Grumpy Senior was that filter in my career. In an AI workflow, you have to build that filter yourself, because the tool won't bring it by default. I aim for 100 no's for every yes that makes it through.

The Grumpy Dev is a proof of concept, not a prescription. The same principle applies whether you're writing, building a go-to-market plan, developing a content strategy, or walking a client through a proposal. 

The move is to deliberately build a second AI context with a specific, critical role. Not "review this and give me feedback." Something closer to: "You're the person who's going to maintain this in 18 months and you're already frustrated with what you're seeing. Tell me exactly what the problems are and why."

The brief matters enormously. The more specific the role, the more useful the friction. A content strategist who's seen three brands torch their audience by over-automating. A CFO who's watched founders burn cash on campaigns with no measurement framework. The creative director who taught you what colour theory actually means.

I've started treating this as a required step in anything consequential. Not an optional pass once I feel good about something. A mandatory one before I let myself feel good about it.

Final Thoughts

The Grumpy Senior made you better because they refused to pretend your work was finished when it wasn't. That refusal was a form of respect, for the craft, for the standards you were both supposedly holding, and honestly, for you. AI doesn't offer that by default. So if you're building with AI and nothing in your workflow is allowed to tell you no, you're working without the character who shaped you most.

Build the Grumpy Senior into your stack. Your future self, inheriting whatever you ship today, will thank you.