Tyler Morgan retweeted
We're hosting another hacknight this Thursday (Oct 22nd) at the @union_ai Bellevue office: This months topic is owning your AI by build agentic model factories!
@niels_ai and @GalarnykMichael are in town and will be there as well!
You'll see how Union ai & Flyte give your AI workflows a durable runtime with infrastructure as context, so agents adapt infra resources, recover from failures, and keep moving without re-running completed work. And because it all runs in your own cloud, you own the full stack end to end: your models, your data, your infrastructure, your IP.
Then we switch into hack night mode: keep building on the example, bring your own models or datasets, experiment with evals and fine-tuning, extend open models to different parts of your agent, or start something new around the same ideas.
Should be fun and i hope to you there!
Tyler Morgan retweeted
Hi, I'm Felix. I'm an eng lead working on Claude. I love watching people take flight and do things they never thought possible.
We often describe that as "being more ambitious" when using AI, which is tricky advice to follow. I wrote a tutorial:
felixrieseberg.com/how-to-be…
Tyler Morgan retweeted
We need a slang term for developers who write code without AI.
What are we calling them?
I love organic food as much as the next guy and we have a weekly organic veg and fruit box from the local farm here
But a lot of organic food is simply a label and still contains pesticides, but alternative ones
@bryan_johnson says organic food typically tests worse than non-organic food
"When we test organic, it typically performs worse than non-organic on many variables. So no, I think it's worthless as a marketing protocol."
From @tbpn
Tyler Morgan retweeted
New in Claude Code: /checkup
Run /checkup to:
1. Clean up unused skills/MCPs/plugins and save context
2. Dedup your local CLAUDE.md against the checked in CLAUDE.md
3. Break up root CLAUDE.md into nested CLAUDE.md's + skills
4. Turn off slow hooks
5. Update your Claude Code to the latest version
6. Enable auto mode by default
7. Pre-approve frequently denied read-only commands
.. And a few other goodies.
/checkup confirms with you before making any changes. Enjoy!
Tyler Morgan retweeted
This is really good, and worth reading in full - it's the best articulation I've seen yet of the idea that driving down costs involved in producing code will increase demand for software and let us take on much more ambitious projects
Every time we've made it easier to write software, we've ended up writing exponentially more of it.
When high-level languages replaced assembly, programmers didn't write less code - they wrote orders of magnitude more, tackling problems that would have been economically impossible before. When frameworks abstracted away the plumbing, we didn't reduce our output - we built more ambitious applications. When cloud platforms eliminated infrastructure management, we didn't scale back - we spun up services for use cases that never would have justified a server room.
@levie recently articulated why this pattern is about to repeat itself at a scale we haven't seen before, using Jevons Paradox as the frame. The argument resonates because it's playing out in real-time in our developer tools. The initial question everyone asks is "will this replace developers?" but just watch what actually happens. Teams that adopt these tools don't always shrink their engineering headcount - they expand their product surface area. The three-person startup that could only maintain one product now maintains four. The enterprise team that could only experiment with two approaches now tries seven.
The constraint being removed isn't competence but it's the activation energy required to start something new. Think about that internal tool you've been putting off because "it would take someone two weeks and we can't spare anyone"? Now it takes three hours. That refactoring you've been deferring because the risk/reward math didn't work? The math just changed.
This matters because software engineers are uniquely positioned to understand what's coming. We've seen this movie before, just in smaller domains. Every abstraction layer - from assembly to C to Python to frameworks to low-code - followed the same pattern. Each one was supposed to mean we'd need fewer developers. Each one instead enabled us to build more software.
Here's the part that deserves more attention imo: the barrier being lowered isn't just about writing code faster. It's about the types of problems that become economically viable to solve with software. Think about all the internal tools that don't exist at your company. Not because no one thought of them, but because the ROI calculation never cleared the bar. The custom dashboard that would make one team 10% more efficient but would take a week to build. The data pipeline that would unlock insights but requires specialized knowledge. The integration that would smooth a workflow but touches three different systems.
These aren't failing the cost-benefit analysis because the benefit is low - they're failing because the cost is high. Lower that cost by "10x", and suddenly you have an explosion of viable projects. This is exactly what's happening with AI-assisted development, and it's going to be more dramatic than previous transitions because we're making previously "impossible" work possible.
The second-order effects get really interesting when you consider that every new tool creates demand for more tools. When we made it easier to build web applications, we didn't just get more web applications - we got an entire ecosystem of monitoring tools, deployment platforms, debugging tools, and testing frameworks. Each of these spawned their own ecosystems. The compounding effect is nonlinear.
Now apply this logic to every domain where we're lowering the barrier to entry. Every new capability unlocked creates demand for supporting capabilities. Every workflow that becomes tractable creates demand for adjacent workflows. The surface area of what's economically viable expands in all directions.
For engineers specifically, this changes the calculus of what we choose to work on. Right now, we're trained to be incredibly selective about what we build because our time is the scarce resource. But when the cost of building drops dramatically, the limiting factor becomes imagination, "taste" and judgment, not implementation capacity. The skill shifts from "what can I build given my constraints?" to "what should we build given that constraints have in some ways been evaporated?"
The meta-point here is that we keep making the same prediction error. Every time we make something more efficient, we predict it will mean less of that thing. But efficiency improvements don't reduce demand - they reveal latent demand that was previously uneconomic to address. Coal. Computing. Cloud infrastructure. And now, knowledge work.
The pattern is so consistent that the burden of proof should shift. Instead of asking "will AI agents reduce the need for human knowledge workers?" we should be asking "what orders of magnitude increase in knowledge work output are we about to see?"
For software engineers it's the same transition we've navigated successfully several times already. The developers who thrived weren't the ones who resisted higher-level abstractions; they were the ones who used those abstractions to build more ambitious systems. The same logic applies now, just at a larger scale.
The real question is whether we're prepared for a world where the bottleneck shifts from "can we build this?" to "should we build this?" That's a fundamentally different problem space, and it requires fundamentally different skills.
We're about to find out what happens when the cost of knowledge work drops by an order of magnitude. History suggests we (perhaps) won't do less work - we'll discover we've been massively under-investing in knowledge work because it was too expensive to do all the things that were actually worth doing.
The paradox isn't that efficiency creates abundance. The paradox is that we keep being surprised by it.
Tyler Morgan retweeted
One reason vibe coding is so addictive is that you are always *almost* there but not 100% there. The agent implements an amazing feature and got maybe 10% of the thing wrong, and you are like "hey I can fix this if i just prompt it for 5 more mins"
And that was 5 hrs ago
Tyler Morgan retweeted
Explain to me why the insurance company will pay $2500 for an MRI when there is a center down the street that will do it for $350 ?
Replying to @mcuban
Drug spend, incl hospital drugs is only 14% of total HC costs. Blaming insurance is convenient, but ins don’t set prices; they pay the bills providers submit. HC costs are high bc provider charges are high & rising fast. If you want to control costs, focus on providers, not ins
I keep thinking of this term in my head because it's so good
"Shotgun to Sniper Strategy"
@marclou coined it
You want to start with a shotgun strategy where you try lots of ideas, launch lots of projects, MVPs etc. add a Stripe buy button to everything
Then see what really gets traction, goes viral, makes money (!) and then what keeps making money over time (like months)
Then you wanna sniper and focus on that project to make it big
Tyler Morgan retweeted
AI workflows are technically impressive, but there’s a deeper reason people are really amped about AI agents. This isn’t just new tech, it’s new psychology.
Until now, very few people have known what it feels like to delegate to total competency.
If you manage great people, or lead great teams, you know how it feels to put someone in charge who will get it done, get it done right, and get it done without drama. That kind of delegation is pure joy.
Delegating to competency lets you forget about it completely. That’s real leverage.
And now anyone can experience that. Everyone can feel it. And it feels fucking great. That’s a big reason why the excitement is real, and fully justified.
Tyler Morgan retweeted
Drone-based solar panel cleaning is starting to look less like a gimmick and more like a practical maintenance tool.
Instead of heavy ground robots or manual crews on rooftops, lightweight drones can now remove dust and sand from panels without physical contact. That matters in large solar farms where soiling losses add up quickly and access is difficult.
The interesting part is not the drone itself, but the workflow.
• Rapid inspection and cleaning in one pass
• No scaffolding, no shutdown of whole arrays
• Minimal water use compared to traditional methods
It shifts cleaning from a scheduled operation to a continuous maintenance task. That is a subtle change, but one that could compound into real efficiency gains at scale.
Still early days, but this is one of those areas where robotics fits the problem unusually well.
—-
Weekly robotics and AI insights.
Subscribe free: scalingdeep.tech
Tyler Morgan retweeted
if you think claude code suddenly got dumber, check /model
they changed "default" from opus back to sonnet.
Tyler Morgan retweeted
Just met a Claude Code user who has been the top daily user numerous times.
He says Codex is better now. – at San Francisco, CA
Tyler Morgan retweeted
My problem with Claude Skills is that they are not skills.
Nothing forces Claude to actually use them.
Claude does whatever it wants.
Even if you specify it explicitly, it's not guaranteed.
These are not skills.
These are just md files.
They can be useful, like manuals or tutorials.
But for some reason, the only thing ppl use them for is:
"You are a professional software engineer"
"You run tests after making changes"
"You think step by step"
Do you really think a model trained on the entire internet doesn't know to run tests?!
This is nearly the only thing you can find when you look inside the actual "skills" published online.
Every GitHub repo, every tutorial, every example.
Even the official examples from the actual creators.
(although they are a bit better than github)
You guys seriously think this would work?
The ONLY way prompts can be valuable is including NEW information.
Things the model DOESN'T know.
Things you CAN-NOT find on the internet.
For example:
- Information about YOUR project.
- Workflow YOU use when working on YOUR project.
- Results YOU found through experiments.
- Experience YOU gained over time.
- Commands YOU use every day.
- YOUR Passwords. YOUR Credentials. YOUR Internal documentation.
- Workflows that only sense for YOUR specific case.
Not BS like:
- Style guides that are general: "how to write good code"
- Personas.
- Step-by-step debugging philosophies.
If you, a flesh and blood human, came to work with me
And on the first day I tell you:
"make sure you run tests every time"
You would say:
"k cool. now what?"
But if I handed you a manual with actual examples of things I use every day BY MYSELF?
- Maybe the actual API of our internal software..
- Maybe a cmd line cheatsheet from my bash history..
- Maybe passwords, path locations, credentials..
- Processes WE actually go through.
- The way WE do CI in OUR project.
Would it help you?
More than "run tests every time"?
Yes, because it is practical.
- You can follow it.
- You can mimic it.
- You can use it.
You don't really need me to tell you stupid basic shit like
"break apart your problem into smaller parts"
Yes, for sure, do it.
But everyone knows this already.
Bro, just take my fucking real bash history.
Do as I do.
Faster and easier for everyone.
Not because I am some sort of a bash god
(i am, but thats a different story)
Because you can't Google this.
It only makes sense FOR OUR PROJECT.
---
This is what I actually use for Claude Code:
- One file concatenated always to the system prompt.
- Inside of it: references to tutorials saved as md files.
- All in a single folder.
- And a small instruction telling the model to use the same folder to save more tutorials if it discovers a new thing that could be useful.
That's all.
And it actually works, this folder keeps growing and opus reads files from it all the time.
collected tutorials about connecting to my own remote machines, actual domains, actual keys, actual paths, actual workflows, actual useful commands to use..
Everything is unique to my setup, my projects.
If I gave them to you and we work together, you would also benefit.
That is the point.
---
What about processes?
Good that you asked.
You want Claude to run tests every time it edits a code?
Make it fucking automatic.
Why do you even let claude decide about this?
Force it to react to something outside its control.
Not make decisions by itself.
These things are probabilistic.
NOTHING will it follow instructions 100% of the times.
---
I seriously went through a ton of "skills" online, trying to find useful ones I could use by myself.
Nothing.
It's all AI slop.
Pasting it back into the model makes no sense.
The only real one I saw was from HuggingFace.
Go check it out, they wrote a full tutorial in it.
With actual commands, code, examples... etc..
This is why it works.
Just tell the model what you would tell another human.
It would not be "you are a software engineer"
For a very good reason.
Tyler Morgan retweeted
The more I code with Opus 4.5, the more I think we’re 6-12mo away from solving software.
The model is pretty much there.
I’ll build like 3 versions of an app in a few hours just to explore options that each would’ve taken me 1-2 weeks <1 year ago.
It’s getting weird.
Tyler Morgan retweeted
We tested one of the most common prompting techniques: giving the AI a persona to make it more accurate
We found that telling the AI "you are a great physicist" doesn't make it significantly more accurate at answering physics questions, nor does "you are a lawyer" make it worse.
Tyler Morgan retweeted
Excellent article
Brilliant article by @profplum99 - I don’t think this could have been articulated anyway possibly better.
yesigiveafig.com/p/part-1-my…






























