Michael Bleigh

Michael Bleigh

@mbleigh.dev

Building the servers for serverless at Firebase. Web platform aficionado.

532 followers127 following495 posts

I hate when I think about a problem for a really long time but can't navigate the tradeoff space to a clear ideal outcome. It's not fun to defend a position that feels "least bad" instead of "good".

There needs to be a benchmark that mixes common acronyms with a few undefined fictional ones to test whether the model hallucinates the acronym's expanded definition. I see this even on frontier models, even when they have the tools available to search for and define the acronym properly.

Software dev is wildly fluid compared to other engineering disciplines. The ability to rapidly iterate alters the fundamental approach of the practice. Dismissals of AI-maxxing oft include a judgment of the work being done as "not serious", but this misunderstands software.

View full thread

Faster iteration means more nimble responses to market demands. Software teams can focus on features one week, performance the next, and reliability the week after that depending on criticality of each relative to product market fit and overall business maturity.

AI is the single largest source of iteration acceleration the industry has ever experienced. We are only beginning to tap into what that really means. An industry defined by iteration velocity can't help but be redefined by AI. And so it has been and will be.

Software dev is wildly fluid compared to other engineering disciplines. The ability to rapidly iterate alters the fundamental approach of the practice. Dismissals of AI-maxxing oft include a judgment of the work being done as "not serious", but this misunderstands software.

99.9% or greater of all software has no life and death consequences. Instead the consequences are commercial market pressures for whatever business domain the software is in. The ability to iterate quickly is the entire reason software has been "eating the world" for decades.

In Pluribus, an alien intelligence usurps overnight and dissolves all previous divisions, establishing a semi-utopic society with regretted casualties along the way and a small group who refuse to partake of the new order. So it's about AI and the software industry, basically.

I feel like the more powerful agents get the more valuable software engineering experience and expertise becomes. Building software is now about providing concise, properly scoped goals and verification criteria. The people best suited to do that? Expert software engineers.

I used to worry about the junior to senior pipeline in an AI world and I'm still not sure exactly how it will work but I'm more convinced now that it will work. It'll be a different set of skills but the same hard-won wisdom can still be acquired by other means, I think.

The age of ticket-closer engineering where you just take well-defined tasks and turn them into functioning code and cash a paycheck is definitely over. But something newer and, imo, much more rewarding is taking its place.

I find myself frequently telling LLMs to explain things like I'm a "semi-technical exec". It's actually not a bad way to get more comprehensible technical writing out of them. 😂

We live in an age of wonders. If you are a software engineer who mostly knows what you're doing there's essentially nothing you can't create and figure out now. The creative potential of a single human is rising on an unbounded exponential curve. It's overwhelming.

It honestly gets me a little emotional. I got into dev tools because I wanted to help individuals and small teams tackle big ambitious things, and I wanted that because when I first got into web dev I had this incredible sense of empowerment I wanted to share.

"This in-app agent could have been a skill" is the new "this meeting could have been an email". If people at your company want to build agent functionality that can only be used inside your app/product, tap the sign:

Unpopular opinion: plan mode is still good and correct. Now that models are more powerful and do longer horizon work it's more important to be aligned up front. A dedicated plan artifact is easier to read and review than inline chat content.

I would estimate a high percentage of all software (80%+) would be totally fine with only automated reviews. Because 80%+ of software written is relatively low risk or changes are easily reversible. AI can free us to focus on the changes that actually do need expert attention.

It used to be that incomplete software was simply missing many things that needed building. Now incomplete software has all the pieces, but the pieces are bad (i.e. slop). Finishing a project is becomes more about removing bad ideas and polishing good ones. This isn't good or bad, just different.

I'm seeing SO MUCH Jev in my feed. My theory is this: most people don't want to train models, they want to build things. So just like how LLMs broke through to the mainstream because they didn't need to be trained to be useful, such is true for Jev and classification tasks.

It's been an interesting change of perspective to be thinking about developer tools in a world where I don't expect developers to hand-write a single line of code.

The conclusion I'm reaching is that the new goal of developer tools is to build something that compounds agent capabilities. It needs to provide infra, tools, and guardrails to radically accelerate some problem domain when tackled by an agent.

It's amazing how frequently "AI did this really stupid thing" turns out to be "I gave AI a poorly-specified prompt and it made different assumptions than I expected". Current models are (usually, not always) good at following instructions if you give them good ones to follow.

Hot take: trying to be more careful about merging AI code is the wrong long-term approach. The better approach is to eliminate one-way doors and make most code more disposable. Sloppy code can be polished/replaced so long as you keep reins on API surface and storage schema.

I genuinely think the demand for tokens is effectively infinite and is bounded only by cost constraints. We will build legions of automatons that are experimenting, tweaking, optimizing, reviewing, condensing, and making sense of the universe of information 24x7x365.

AI code is like water: it will slosh around to fill whatever container it's poured into. If you don't provide any constraints you're going to end up with a big mess on the floor. The new job of software engineering is to specify verification+guardrails that hold the water.

An unintuitive thing about design docs: a doc that is clearly written but wrong on the substance is better than a doc that is hard to read but flawless on the substance. Design docs are communication tools to align humans. You can win at design but fail at design docs.

If I come across a crisp, five-page design doc that has two major flaws in its underlying assumptions, I can identify them in a 10 minute read and we can have the needed discussion. If I have to review a 35-page AI-generated treatise, I'm going to miss important details.

Use AI to help you research and even draft your design docs, but your goal is not an exhaustive survey of the subject. Your goal is to distill a complex subject into its essential elements. AI can't do that well yet, so you have to.

What we need as a companion to WebMCP is WebACP that lets me bring an agent of my choosing into the browser. I don't need my agent to build a browser and I don't need my browser to build an agent. I need my agent in my browser.

The primary artifact you need during design for agent-first development is a list of invariants. "Here's what absolutely must be true about the final result." This will often include a mix of concerns and will often include specific API contracts, specific test scenarios and expected outcomes, etc.

View full thread

You do have to be careful -- you can't put anything in the invariants that you don't actually mean is invariant, or you'll wake up to twisted code contorted around a false assumption.

The process ends up being: DESIGN: Invariants -> Design w/ Milestones -> Adverserial Design Review IMPLEMENTATION (for each milestone): Implement -> Adverserial Code Review Loop -> Adverserial Verification Loop

The primary artifact you need during design for agent-first development is a list of invariants. "Here's what absolutely must be true about the final result." This will often include a mix of concerns and will often include specific API contracts, specific test scenarios and expected outcomes, etc.

View full thread

Then the secondary tab is a fully LLM-owned detailed design based on the invariants + codebase investigation. If I find something wrong in the design, I can update the invariants and redo the design.

I can have the design pressure-tested against the invariants and then I can also have the implementation pressure-tested against same.

The primary artifact you need during design for agent-first development is a list of invariants. "Here's what absolutely must be true about the final result." This will often include a mix of concerns and will often include specific API contracts, specific test scenarios and expected outcomes, etc.

View full thread

But maintaining a list of invariants makes it easy to put a verification loop at the end of an implementation cycle, and is also something that is easiest for a human team to align on.

I'm experimenting with design docs whose primary tab is just "here's the list of agreed upon invariants" that I might use an LLM to assist me in writing but I carefully review and edit every line to make sure I agree.

The primary artifact you need during design for agent-first development is a list of invariants. "Here's what absolutely must be true about the final result." This will often include a mix of concerns and will often include specific API contracts, specific test scenarios and expected outcomes, etc.

I haven't really found "spec-driven development" where the spec is a gigantic long document to be very useful. The spec begins to rot the moment it's written, and the codebase is the actual source of truth.

As companies grow, they build processes that leave no room for judgment calls. The default posture becomes oriented around fear of idiot / bad-faith actors, putting a huge tax on good-faith actors who have a good reason to do something a little bit risky. It destroys velocity.

Agents' overeager coding makes us all into editors. The PR is ready not when there's nothing left to add, but when there's nothing left to take away.

Not supporting Cmd/Ctrl+Click to open new tabs on navigation is the usability papercut that most frequently sends me into a state of barely-contained rage when using an app.

Bigcos love to add approvals to everything without considering desensitization. Any individual has limited "pay close attention to thing I'm approving" bandwidth. The more often approval is required, the less carefully each review is performed. Rubber stamps become the norm.

If you *actually* care about the security of your platform you have to also care about usability. If it takes 35 steps for users to do the right thing and 3 to do the wrong thing, you are incentivizing bad practices. The "pit of success" is hardest to construct for security.

How has Apple been allowed to get away with the absolutely dismal quality of file search on Mac? It literally couldn't find a folder called "records" in my Downloads folder when I searched for "records".

"How does the harness handle long-running shell commands" turns out to be I think the most consequential question for overall satisfaction for me personally. Antigravity actually nails this. After a short timeout, the command goes into the background and retriggers on complete.

This lets you continue work in the session while waiting for e.g. a long deploy. It can also schedule self timers to check in on progress of long running scripts. Huge QoL improvement and something I miss when I'm using agents that don't have it.

Agentic coding is a ladder, and I think it's most effective to climb it one rung at a time. Loops are very powerful but if you try to jump straight there without first understanding both interactive and unsupervised agentic tasks you're not going to build effective loops.

My personal experience has been that I get comfortable with one rung and then eventually start feeling "cramped" as I master the current toolset. Then (and only then) I start trying the next level of abstraction to see if it works for me.

One pattern I find myself reaching for frequently these days is to gather data into a heavy JSON "kitchen sink included" format and then build lightweight CLI renderers that slice and dice the data into various token-efficient text views for an agent to understand.