DEV Community: Craig

The First Real Pause

Craig — Sun, 04 Jan 2026 23:45:26 +0000

This is the first week in about 21 years that I haven’t had a job to go back to.

I’ve changed roles plenty of times, but I’ve almost never stopped. One job would end on a Friday, the next would start on a Monday. Even holidays never fully disconnected me, there was always a return date, a backlog, a sense of things waiting patiently in the background.

This gap feels different.

What surprised me most wasn’t stress or panic. It was calm. No inbox quietly filling up. No problems queueing. No feeling that I was borrowing peace from a future version of myself who’d have to pay it back later.

A few days into this break, I heard someone say that most people who think they want to quit don’t actually want to quit — they just need real rest. Not a long weekend. Not a forced holiday spent keeping one eye on Slack. Actual space.

That landed for me. Not as permission to disengage, but as permission to recalibrate.

I’ve been using this time to write, think, spend time in the garden, and give proper attention to things I normally squeeze into the margins. It doesn’t feel like stopping. It feels like sharpening.

I wrote a longer piece reflecting on what this pause has felt like, why it’s unfamiliar, and why it matters — especially for people who’ve been moving continuously for years.

👉 Read the full post on my blog: The First Real Pause

What Comes After “Senior Developer”? (The Ceiling No One Talks About)

Craig — Thu, 07 Aug 2025 08:11:27 +0000

Most career ladders in tech look like this:

Junior → Intermediate → Senior →
... and then what?

For many devs, the answer is: nothing. You’re “valued.” You’re “the backbone.” You’re also stuck.

In this piece, Why coasting feels easier than change. And why no one warns you about this ceiling

I’ve been there. You might be too.

👉 Read the full post: Senior Forever

Retros Suck, But They Don’t Have To

Craig — Tue, 15 Jul 2025 09:30:41 +0000

Raise your hand if this sounds familiar:

Your team rolls into the retro half-distracted
You rehash the same pain points you talked about last sprint
Someone adds action items that no one will follow up on
Two weeks later, nothing has changed

Yeah, me too.

A friend of mine put it best:

"We stopped doing retros. They just turned into venting sessions that created tasks no one followed up on."

Honestly? That tracks.

So what do you do instead?

I’ve sat through every retro format imaginable — sticky note boards, sailboat metaphors, start/stop/continue, fancy tools.

None of it really helped until we made one change:

We stopped trying to fix everything.

Instead of asking:

"What went wrong?"

We started asking:

"What’s one thing in our control we can improve next sprint?"

It’s a subtle shift, but it changed the tone.

Suddenly retros weren’t just post-mortems.

They were decisions. Small, actionable, team-owned decisions.

If this resonates...

I wrote a short PDF guide called Retros That Don’t Suck.

It’s free, blunt, and based on 20 years of real-world agile and post-agile pain.

It includes:

A repeatable format you can run in 30 minutes or less
A way to surface real problems — not just process noise
Tips for getting actual improvements to stick
Bonus: when to kill the retro and do something better

👉 Grab the free guide here

(Just an email. No spam.)

Would love to know if this lands with you — or how your team’s handled broken retros.

Ticket-Driven Development Is Not a Process. It's a Trap.

Craig — Mon, 23 Jun 2025 02:13:16 +0000

Somewhere along the way, “just pick up the next ticket” became the default dev workflow.

And that’s the problem.

Ticket-Driven Development looks like productivity—until you realize no one’s questioning the work, improving the system, or even thinking anymore.

🧠 It trains developers not to think.

Asking why is seen as overstepping. Improving code is gold-plating. Creativity becomes risk.

⚠️ Velocity isn't progress.

You can burn down 30 points a week and still be going backwards if every fix just creates more mess.

📉 It slowly erodes morale.

When engineers treat code like it belongs to someone else, they stop caring. That’s when quality dies.

You don’t need a new framework. Just permission to care again.

Read the full take:

👉 Ticket-Driven Development: The Fastest Way to Go Nowhere

You're Not Refactoring — You're Just Moving Code Around

Craig — Thu, 19 Jun 2025 03:06:13 +0000

You renamed UserHandler to UserProcessor, made five new classes, and called it a refactor. Spoiler: it’s not.

Refactoring is supposed to improve structure without changing behavior. But too often, it’s just an excuse to shuffle code around — adding layers, not clarity.

How to tell you’re just moving code around:

You renamed things but didn't remove any logic
You created new abstractions that wrap existing logic one-to-one
You deleted helpful comments and added cryptic method names
You added interfaces with one implementation — your own

Good refactoring feels different:

Less code, fewer dependencies
More understandable by the next dev
Easier to test, or no longer needs tests to make sense

Refactoring is editing. It’s not furniture rearrangement.

👉 Full version with examples and dry wit here:

thecynical.dev/posts/youre-not-refactoring

'Senior Developer' Doesn't Mean What It Used To

Craig — Wed, 04 Jun 2025 22:30:27 +0000

Not long ago, the word senior actually meant something.

It meant you'd survived legacy systems, knew when not to ship, and maybe even carried a pager once. These days?

“I’m the only dev at a 3-person startup. So I guess I’m Senior Staff Lead Principal Architect III.”

Meanwhile, some companies are going the other direction — removing job titles altogether so no one feels left out.

Flat orgs. Inflated titles. Diluted meaning.

The title "Senior Developer" used to imply wisdom and experience. Now it might just mean “the least junior person here”.

I wrote a post about the erosion of that title, what it means across industries, and why it still matters — even if we’re all pretending it doesn’t:

👉 Read the full post on The Cynical Developer

What does “Senior” mean in your world?

Release Managers in 2025? Really?

Craig — Wed, 04 Jun 2025 21:56:39 +0000

I’m scanning the job boards again. My contract’s winding down. And what do I see?

Release Manager.

Right next to it?

Scrum Master.

And I can’t help but wonder — How is this still a thing?

Release Manager: The Role Automation Forgot

CI/CD has been a thing for over a decade. Trunk-based development? Same. But we’re still hiring people to coordinate deployments by hand.

If your team still needs a Release Manager, your pipeline isn’t the only thing stuck in 2010.

Scrum Master: The Ritual Facilitator

Scrum is old. The ceremonies are tired. And most teams I’ve seen are doing stand-up theatre — not collaboration. Hiring someone to facilitate the performance doesn’t help.

Coordination Is Not Delivery

We’ve confused coordination with progress. These roles paper over bad architecture, broken trust, and duct-taped processes.

The slightly longer original + More cynicism (and a small plug for my next role) here:

👉 thecynical.dev/posts/obsolete-jobs-in-2025

Have We Lost Our Way? (A Developer's Small Crisis of Confidence)

Craig — Wed, 28 May 2025 09:13:52 +0000

There was a time when we built things to last.

Now we build MVPs to maybe survive the quarter.

This isn’t a post about how everything used to be better. It’s just an observation — and maybe a quiet protest — about how easy it is to confuse activity for progress when the rituals of delivery become more important than the value delivered.

Have We Lost Our Way?

Somewhere along the way, we started measuring the number of tickets closed instead of whether anything actually got better.

We replaced architecture with story points.

We replaced meaningful iteration with ceremonies so performative they deserve their own Oscars category.

We got really good at “velocity” and forgot that shipping garbage faster is not the same as improvement.

“Deliver working software.”

Remember that one? It used to be a principle.

Now it’s just something you hear right before someone tells you they’re rewriting a service because the old one was written in the “wrong” language.

This isn’t nostalgia

I’m not saying waterfall was better.

I’m saying we’ve swung too far the other way.

Where once we spent six months planning a login form, now we spend six months pretending not to plan anything — and somehow end up with three frontends, five services, and nothing reusable.

Every generation of devs thinks they’re the first to see the mess.

But we’ve been here before. And we’ll be here again. The best we can do is notice it earlier, name it honestly, and maybe do a little less damage next time.

🗂 Originally posted at thecynical.dev — a side blog for developers who’ve survived legacy Java, agile transformations, and frameworks that promised joy but delivered YAML.