The problem with the "if it works who cares what the code looks like" mindset for agentic work is that it assumes the agent has a perfect understanding of "works." Realistically, things are underspecified, agents make bad assumptions, etc.
To be fair, agents are pretty good at unit test coverage. They're pretty bad at designing human experiences (API, CLI flags, etc.), especially cohesive ones for future roadmap plans they may not have visibility into (unless your backlog is perfect and vision fully laid out, which I doubt). They're bad at knowing where performance matters and what type (CPU vs memory tradeoffs). They're bad at where compatibility matters and where it doesn't (and tend to err on the side of preserving it without further guidance). Etc.
Unless you have this ALL specified, you can't possibly claim "it works" without taking a look and thinking about it.
It’s 2018 and your coworker just sent you a 400 line pull request.
You get a cup of coffee and sit down to review it.
It’s beautiful. Elegant micro-refactors. Crispy method names.
You catch a few things, but that’s ok. It’s part of the dance. They didn’t consider extensibility on part of their API. Here’s a comment buddy.
They respond in an hour saying they think we should do one piece differently than your comment. Hey let’s jump into a room and figure it out. We can’t just agree to disagree, this code is too important.
The PR merges and goes to prod. You feel a shared sense of ownership and accomplishment.
That night you go to sleep and dream of that code. You can still see the shapes of it on the backs of your eyelids, your IDE syntax highlighting sparking neurons in your reptile brain.
You go to work the next day ready to go. You understand the system. N is your foundation. Time to build n+1.
i actually don't want this "but you don't review compiler output either" meme to die.
it's the perfect signal for being immediately able to ignore someone in this space.
I think both extremes appear once either one exists.
AI is different from most technologies because its boundaries are so undefined. It can be framed as capable of almost anything, and when it fails, the explanation is often that the user prompted it wrong or that the models are not good enough yet.
That makes it hard to evaluate the actual state of the technology. Its correctness is often judged anecdotally.
In science, something must be falsifiable: there needs to be a way to prove that something works, and a way to prove that it does not. You cannot keep saying the test failed only because it was not performed correctly, especially when there are no clear instructions for what “correctly” means.
Everyone is slowly coming to this realization, and I assure you, no one is running multitudes of agents overnight. No one that is doing anything of substance at least.
There _are_ people pretending to be scientists, or fully caught up in their drug infused AI overdose, that think their slop machines are changing the world. They're not tho, and they're just wasting a bunch of money and compute to create a lot of LoC that will just get thrown away.
The state of the art is still "can we even one shot a production quality patch that we wont regret later", and its rarer than you'd expect based on discourse.
most people think ideas come from:
- insight
- intelligence
- taste
- reading
but in practice they actually come from:
- building the wrong thing
- hitting a constraint
- getting embarrassed by users
- realizing the obvious thing you missed
- noticing the second order effect you couldn’t see from the couch
a really great idea is the *output* of the work, not the input.
I keep thinking about built-in agency vs. agent sprawl.
Custom agents may become the new custom fields of AI software: easy to add, hard to manage, and a long-term source of complexity overhead.
You end up with hundreds of agents doing narrow tasks across systems independently, conflicting with each other’s changes and burning tokens as they go instead of having one system operating in an agentic way.
You can now enable Claude to use your computer to complete tasks.
It opens your apps, navigates your browser, fills in spreadsheets—anything you'd do sitting at your desk.
Research preview in Claude Cowork and Claude Code, macOS only.