One of the biggest problems with using LLMs as a google replacement for programming, is that getting zero relevant results on google used to be a signal that you had the wrong idea about the root cause. Whereas LLMs will happily indulge any terrible idea you suggest.

There’s a big difference between “no, we can’t” and “no, we shouldn’t” The former is declining in value; the latter increasing in value Conflating the two misses out on an important quality of the AI software revolution

GitLab has a solid core product for the AI era and I think their stock has been over-punished given both the financials pure play offering. They’ve got answers for the entire SDLC, are provider agnostic, and have a perfect chance to capitalize on the “sandboxed agents” trend running at relevant points in the SDLC. That said, 100% agree w/this. The UI/UX is completely overwhelming. There is too much on each page, and it distracts from the good stuff the platform offers. A massive UI overhaul would be a great way to re-launch their product and convince the market they’re a serious alternative for more than just big enterprises.

I think customers would be much happier with 2 separate status pages: 1. Uptime - traditional status page with incidents that affect uptime metrics, are deterministic known bugs, and can be fixed fast 2. Quality - a status page that acknowledges degradation of outputs based on some combo of open benchmarking and customer reports (this issue was overwhelmingly prevalent amongst Claude power users here on X) I get that these degradations could take days or weeks of correlation data to pinpoint. It was the fact that Anthropic blamed the users and didn’t acknowledge it could be something that was changed internally that caused problems. No, customers wouldn’t be happy seeing issues go up on the “quality status page”, but would at least appreciate acknowledgement of the issue These sorts of issues just can’t be represented properly on a traditional status page

It’s crazy to think that malicious hackers, many of which are highly technical are using the same AI tools to build their exploits while the industry is reducing the tech workforce, relaxing code standards (implicitly), and pushing more LOC than ever before

Pre-LLMs, human devs often constructed codebases that struck a practical balance between codebase philosophy (ie DDD) and pragmatism. In the human world, splitting up every feature into repositories, value objects, factories, entities, etc didn’t *always* make sense So we implemented the philosophy in areas where it mattered, and took pragmatic shortcuts in areas where it didn’t (ie direct domain model interactions in the controller vs service layer, it’s the beauty of a framework like Rails!) I think one of the interesting findings here in the LLM era is that it can be challenging to encode these pragmatic decisions into a rules file It’s very hard to tell an LLM, “if the feature is simple, skip the DDD philosophy and all the patterns we use and be pragmatic about it, but when it’s complex, use all established codebase patterns” It’s much easier to say, “this codebase uses DDD. All controllers call a service, which loads an aggregate through a repository, and invokes behavior on the aggregate” The LLM does great with those sorts of instructions. Even though there’s a lot of extra code to write and most features don’t need all the ceremony, it feels increasingly valuable to have these consistent patterns in a codebase Given the vast number of brand new startups funded 2025-2026, it wouldn’t be shocking to see many of these companies adopting old “over-engineered”, “overly-ceremonious”, “impractical” engineering ideas at the start of their codebases to optimize for consistent LLM outputs It’s obviously more token costs to generate this much extra code, but the maintainability benefits seem to offset that in the long run

Bob runs an essay-writing business in college. Bob’s essays receive A’s at the best price, so his business grows. Bob loves writing the word “egregious” in every essay. Bob scales his business, capturing 50% of essay market. Now, “egregious” shows up in more essays, despite not being popular before. The word “egregious” hasn’t become more popular. Bob is just writing more essays.

Hand-writing code, reading technical blogs and books, listening to conference talks etc is probably one of the most important habits to maintain at some level right now (even if just 1 day / week). We all know hand-writing code isn’t practical for the demands of the modern day SWE job, as scope has 10x’d at most companies who are paying attention. That’s fine and expected, but just like we built gyms when corporate work kept us inert most of the day at a desk, we need these counter-balancing “brain gym” activities to keep clarity in both our product thinking and engineering thinking. LLMs revert to the mean, so how do we keep excellence in both our products and engineering culture? These things actively sharpen our critical thinking. They are intentionally slow. Slowness IS the feature here. Slowness allows us to chew on tough concepts for a while rather than a quick follow-up to an LLM who will spit out yet another wall of text that feels smart yet your brain is incapable of internalizing because you’ve found yourself in an endless loop of re-prompting every time something doesn’t make sense. You feel like you’re absorbing so much new information and “orchestrating” everything when really, you’re being fed mountains of options and have lost the agency to steer the ship. Clear technical thinking is the single most important engineering skill right now. The LLMs are becoming experts at implementing a clear spec. We lose our quality of outputs when the LLM-induced laziness kicks in on hour 8 of tapping the keyboard and we no longer remember what the spec was. We give into the temptation to say, “I think the LLM has it from here”. But it doesn’t. It doesn’t know your business and will introduce compounding complexity if you let it. In software, the last mile is the most important, and in the agentic era having the ability to think clearly and subtract things is the path to achieving quality software.

Me prompting claude at 3AM:

Pre-IPO labs: - Release category-killing products every few months to increase TAM and create an appearance of existing in all markets. No clear path to maintaining these products profitability long term - Reserve a set of "too dangerous to release" models behind closed doors to increase uncertainty around progress - Ensure new model releases are served at full capacity, leader on benchmarks, and nerf prior models - Subsidize usage to capture market share Post-IPO labs: - Slash 50% of new product efforts, consolidate back to main offering, move further into B2B space - 2x monthly sub prices, move towards usage-based pricing - Acquire existing SaaS to replace greenfield offerings they developed in lead-up to IPO - Leadership shakeups - Multiple compression as expectations dampen, models commoditize, AI integrated strategically within other companies who realize these don't need the most powerful model to achieve their objectives

So long as the code-owner is a human, and that human is liable for failures of the code, the human will be incentivized to review every line of code. And so long as the human is incentivized to review every LOC, AI code generation becomes a firehose of data with a human throughput constraint. I think we’re headed for a world where code ownership changes and agents become entirely liable for certain areas of the codebase while humans become liable for other more critical areas. This middle-ground where humans are attempting to work alongside agents is bad for human productivity and bad for agent productivity. We like to think that “agent-augmented development” is a viable outcome, but I have yet to meet a human developer who is genuinely good at using *some* AI. You’re either in “AI mode” or “Brain mode”. The context switch between the two doesn’t fit our brain’s hardwiring, and being in “AI mode” for too long a period deteriorates critical thinking ability in the majority, if not all human devs (ifykyk, lots of unspoken cognitive effects that will be studied and proven in the next few years). Agent harnesses like Claude Code were huge breakthroughs for productivity, no doubt. But trying to shove them into the existing SDLC, tech interviews, and tech budgets isn’t going to work. I think many startups and devs have realized this and are working on the new way of building in tech, and it can’t come soon enough. There’s probably a place for both the “new way” and the “old way” in every company, but until we define where the boundary is, we’ll keep pushing this unsustainable idea that developer brains can expand to the parallelism agents are natively comfortable with.

LLM UIs need a “learn mode” where you ask for review of a general topic, get a review guide, and it pins that original review to the top and goes into a follow-up mode answering rapid fire questions; collapsing answers into expandable drawers

Claude Code outages are tough during the workday… But have you ever had Claude go down 3 minutes before an AI driven interview and stay down the entire interview?

Tragically I am continuing to find that the most effective guardrail against slop is extremely talented engineers doing very thoughtful, human code review

Smaller X accounts, how are you using the app in 2026?