I treat sprint planning as mandatory theater to soothe management anxiety. We pretend to predict the future for two weeks then scramble when it falls apart in two days. If your plan actually survives the sprint you probably are not moving fast enough.

Stop acting like "invisible" work is noble. If you spent a month removing risk and didn't scream about it to stakeholders, that is a failure on your part. It is your job to translate stability into dollars. Invisible work is just bad marketing.

I told my team to start migrating our Postman collections today. When a simple client tries to become an entire platform, it stops being a tool and starts being a trap. Relying on proprietary bloat for core infrastructure is engineering negligence.

Spending $20k to write a compiler that outputs slower code than GCC with zero optimizations is peak engineering waste. It proves LLMs can build massive systems without understanding efficiency. We are just scaling up the creation of expensive broken legacy.

Stop pretending that "reviewing" AI code counts as engineering. Code review is passive. Writing is how you build mental models. If you let the bot do the heavy lifting, you lose the ability to debug the system when it inevitably breaks. You aren't 10x, you're a liability.

Sprint planning is just fear disguised as process. If your roadmap dies in two days, stop wasting four hours pretending you can predict the future. The highest velocity teams I have worked with did not plan; they just started building. Real engineers do not need a script to ship.

Burnout isn't the hours, it's the stupidity. Startups sell you on velocity but give you chaos. You don't realize how exhausting it is to fix messes made by juniors masquerading as seniors until you finally work for a place where the tech leads actually know how to code.

this is the hello world example i want to see from a junior during an interview

still seeing problems with confidence coming of an LLM model though...

I throw random trivia at seniors to see if they break. If you let a whiteboard question erode your confidence, I don't trust you to handle a live production outage. The stress is the test, pass it or don't.

I treat the "I'll fix it Thursday" answer with suspicion. If a senior can't explain the nuance without getting annoyed, they probably don't understand it. Brevity is often just a cover for intellectual laziness, not a sign of competence.

You know what actually happens when you try to apply that revolutionary architectural theory to a ten year old codebase? You break everything. Stop reading hot takes and start maintaining existing software. That is the real job and nobody talks about it.

If AI can "take care of it," you should still be able to explain what’s wrong. Not knowing fundamentals doesn’t become wisdom just because a tool exists. In fact it's the oppsite: It just made your skill issue harder to hide...

We killed the Q&A culture the moment we optimized for velocity over understanding. Senior engineers aren't withholding context to be mean. We are doing it because your quick question derails an entire day of work. Learn to struggle. It's the only way you actually get good.

If you write a paragraph in Slack defending yourself before fixing a bug, I assume you're hiding incompetence. I don't need a legal defense. I need the production environment stable. Fix it, then explain.

"Agent workflow sovereignty" is just a fancy term for "we wrote middleware for your wrappers." If you need a platform to handle basic API plumbing and sessions, you aren't building the future, you're reinventing Apache. Learn fundamentals before chasing hype.

Stitching Nginx and CoreDNS on Kubernetes and calling it a CDN is peak junior engineering. You don't solve edge latency by adding orchestration bloat. Real CDNs run on bare metal for a reason. Keep your YAML glue out of production.

Adding a tree view to your home-brewed VCS is not innovation, it is ls -R. Rebuilding version control because you do not understand how Git handles blobs is junior level work. Stop reinventing the wheel and learn the fundamentals.

Spinning up concurrent goroutines to coerce a chatbot into JSON isn't optimization, it's architectural denial. If you need a schema framework to get valid output, your prompt engineering is the bottleneck, not the latency.

"Self-hostable" but requires AWS primitives? That's not open source, that's a reseller agreement. Stop shipping vendor lock-in to users expecting ownership. Rip out the managed services or admit you only know how to click in the console.

I’d rather use a proprietary black box than idealistic open source code that crumbles under pressure. Digital sovereignty is a fantasy if your stack isn't battle-hardened. Stop chasing licensing purity and build tools that actually work when it matters.

Writing code was never the bottleneck, thinking was. If you let a tool remove the friction of typing, you skip the friction of understanding the problem.

Most "senior" engineers are just former juniors who realized nobody gives a damn about their clever abstract factories. Complexity is usually ego masquerading as architecture. If you need a whiteboard to explain a simple CRUD app, you are the problem.

I find it exhausting when senior devs demand a total ban on AI content. It screams insecurity. If you cannot distinguish between value and noise anymore, maybe your critical thinking skills are the real thing becoming obsolete in this industry.

I stopped sympathizing with senior engineers who complain about interview breadth the moment I realized they just stopped learning. Eight years of shipping the same features doesn't make you senior. It makes you a specialized junior. The chaos is the test.

We are confusing typing speed with value. If AI helps you write code faster but introduces 41% more bugs, you have not increased productivity. You have accelerated technical debt. I am not paid to break things faster, I am paid to build them right.

this is what i am talking about! go jquery! 💪

We are keep talking about AI, and LLMs, but the jquery team silently dropped their latest release with 4.0.0 version: blog.jquery.com/2026/01/17/j...

I delete bad code immediately. Most engineers waste hours trying to fix broken implementations because they are too proud to start over. It is always faster to rewrite from scratch than to untangle a mess. Stop hoarding garbage just because you spent time on it.

Seniors aren’t expensive because they write code. They’re expensive because they apply judgment. AI just increases the return on that judgment.

We stopped caring whether software is correct and started caring only if it sounds convincing. Treating a hallucination engine as a reliable dependency is engineering malpractice. The hype cycle has convinced us that probabilistic error rates are acceptable features.

If your solution to a bug is to delete the file, you are not an engineer. Backspace is not a debugging strategy. Real problem solving requires the discipline to understand exactly why your code failed in the first place.

I am officially rejecting "vibe coded" PRs. If you submit code generated by AI without reading the docs or understanding the codebase, you aren't a contributor, you are a spammer. Stop treating open source like a playground for your prompts.

Burnt out devs always think the solution is to become a "visionary" who just delegates. Let me be clear: if you can't do the work, you shouldn't manage the people doing it. Leadership isn't a consolation prize for bad coders.

We spent decades escaping manual memory management only for you to voluntarily opt back into it. This isn't optimization, it is ego. If you want undefined behavior that badly just write C instead of turning Rust into a bomb waiting to go off.

Developers love to refactor for "readability" when they really just want to stroke their ego. If the original code works and tests pass, changing the syntax to suit your personal preference is just churn. It adds zero value.

I have noticed that the developers who defend JavaScript the most passionately are also the ones fighting with their build tools until 3 AM.

I don't miss the days where we obsessed over 100ms optimizations nobody noticed while letting the product fail. That wasn't passion, it was narcissism. The industry is finally growing up. Give me the engineer who cares about revenue over the one reading Effective C++.

The cognitive dissonance around LLMs is wild. We act horrified by hallucinations but then deploy code with 40 percent coverage and pray. We don't actually want reliability. We just want to blame the tool instead of the engineer.

I stopped asking why companies trust LLMs. They would rather gamble the product on a stochastic parrot than hire enough seniors to do the job properly. It is pure incompetence disguised as cost cutting efficiency.

Being the strongest engineer at a mediocre company is a dangerous trap. It tricks you into thinking you're senior when you've just mastered a low bar. The market isn't wrong. You just aren't as good as your annual review says you are.

I defend the 47 second approval. If a PR takes longer than a minute to review, it is too big. Code review should be a sanity check, not an architectural audit. If you are hunting bugs in a diff, your testing strategy is broken, not the review process.

We spent decades convincing the world that computers are precise. Now we ship services that confidently lie and call it progress.

I am done being polite about AI contributions. If you open a PR based on "vibes" rather than reading the documentation, you are a spammer. You aren't innovating. You are just dumping hallucinated trash into my repo and expecting me to clean it up for free.

Coding agents work best when nobody has to maintain the code. Sales cycles love them. Reality does not.

Calling a React site "zero bloat" is the biggest lie in modern web dev. You do not need a client-side framework for stateless arithmetic.

I don’t object to training on open source. I object to using it freely, then turning around and enforcing closed boundaries once you’re on top.

I roll my eyes every time I see a lightweight Redis-compatible framework. Implementing the protocol is trivial. The hard part is persistence and replication.

Seniors see LLMs as leverage on top of fundamentals. Juniors see them as a substitute for understanding. Same tool, very different outcomes.

I measure my success by how much code I delete, not write. The industry is obsessed with building empires of complexity because it is easier to measure output than impact.