EMM_386

but you don't see "load bearing" nearly as often in prose written by people

Unfortunately, we're starting to now.

Thanks to Claude.

Yes but one of the key things about subagents is they keep all of their tool calls and exploration out of the parent context.

If you plan on continuing on in the parent, and aren't going to necessarily be touching the systems the other agents are exploring, it can be worth it.

It's useful in certain situations where the parent context may need the "10,000 foot" view of something without going back in there. But subsystem-specific AGENTS.md/CLAUDE.md files are still superior and accomplish the same thing. The problem with those is they can become stale.

Yes - Anthropic badly needs this same "here's a reset, use it when you want".

It's vastly better this way. Sure, it may impact the bottom line but it's a huge customer satisfaction win.

When Anthropic randomly resets me and I've only used 2%, that's worthless. When OpenAI tells me I have 3 resets available to use whenever I want - it's wonderful.

Although they can technically do it, I wouldn't be asking LLMs to generate binary files like PNG with alpha channels, no matter how simple that may seem. If it's easy enough to manually create one yourself, I would do that.

The best way for LLMs to do this is likely to write a scratch program (which is what it seems to have reached for in the second half), write code (which they are good at) and have the library create the image.

At some point it is just easier to handle such things yourself, and use them with text-based formats.

This is an excellent and very interesting write-up.

It's so refreshing to read technical articles that are clearly written by a knowledgeable human and explained perfectly like this. By walking the reader through this with the example screenshots it unfolds and gets more interesting as you continue reading.

It's also strange to realize that these days, most articles are not like this.

Be careful with this sort of logic ("reflection=expensive").

Everything should obviously be measured.

I've worked with large .NET code bases that used attributes for things like plugins and it was completely negligible for overall performance in the grand scheme of things.

I always use a standard workflow and it has never been a problem.

- Define the task and the goal, write a short spec document (markdown is fine)

- Point the agent at it in plan mode and have it write the plan to disk with phases. Iterate on its plan if necessary here and now.

- Have each agent tackle a phase and have it update it as a living document (switch models if some phases are more difficult than others)

- Clear and repeat until done

I've never had to overcomplicate this and it's worked both on enterprise-scale projects and personal projects. I am not sure what I'm missing - if anything.

"I don't see them be making the next great song"

Meanwhile, songs are hitting number one on some charts on Spotify that people think are humans and are actually AI. And Spotify has to start labelling them as such. One AI "band" had an entire album of hits.

Also - music is a subjective. Mathematics isn't.

And in this case, an LLM discovered a new way to reason about a conjecture. I don't know how much proof is needed - since that is literally proof that it can be done.

If an AI agent finds zero bugs in a software utility, how can that be viewed in the sense the AI agent is not very good at finding bugs?

What if there are actually zero bugs?

Five issues felt like nothing as we had expected an extensive list.

The expectation here may not match reality, but not necessarily because Mythos isn't as capable as claimed. curl may just happen to be a well-hardened tool that doesn't have too many security vulnerabilities in its present state.

There are terminal libraries that do this:

https://github.com/vadimdemedes/ink

Which is what Claude Code CLI uses (or was using?) and it caused many issues such as flickering, thrashing, and latency.

You don't need to go back to coding by hand if you know how to do it already. There is a middle ground.

If you understand good software architecture, architect it. Create a markdown document just as you would if you had a team of engineers working with you and would hand off to them. Be specific.

Let the AI do the implementation of your architecture.

I think Firefox applies more aggressive subpixel rendering and path smoothing before stroking. It resamples the glyph outline path at a higher precision level before handing it to the stroke algorithm.

"in September 2025, Banksy painted a mural on the Royal Courts of Justice depicting a judge bludgeoning a protester with a gavel"

His other works aren't subtle.

You can read the latest Claude Constitution plus more info here:

https://www.anthropic.com/news/claude-new-constitution

That's just ... absurd.

The flaw itself is absurd but then just accepting it as "by design" makes it even worse.

Tools like Figma are for an era (and persona) who still wants to have all the various knobs and dials to dial in exactly what they want

The Anthropic video on that page at 0:53 literally shows them clicking a "knobs" button and adjusting the pixel CSS value.

I know it's not exactly the same ... but it has that functionality to a degree.

How expensive can it be?

I just randomly looked at Railway and for $20 a month you get a whole lot. I've hosted many a web project (successful personal projects and enterprise projects alike) and I don't see a large barrier to entry on "hosting a website" here.

Blocking AI scrapers and crawlers is not a huge ordeal. Planning for a unicorn before just putting a product up isn't the way to go.

https://railway.com/pricing

This might make things worse not better.

Yes - the postinstall hook attack vector goes away. You can do SHA pinning since Git's content addressing means that SHA is the hash of the content. But then your "lockfile" equivalent is just... a list of commit SHAs scattered across import statements in your source? Managing that across a real dependency tree becomes a nightmare.

This is basically what Deno's import maps tried to solve, and what they ended up with looked a lot like a package registry again.

At least npm packages have checksums and a registry that can yank things.

This is getting really out of control at the moment and I'm not exactly sure what the best way to fix it is, but this is a very good post in terms of expressing the why this is not acceptable and why the burden if shifting on the wrong people.

Will humans take this to heart and actually do the right thing? Sadly, probably not.

One of the main issues is that pointing to your GitHub contributions and activity is now part of the hiring process. So people will continue to try to game the system by using LLMs to automate that whole process.

"I have contributed to X, Y, and Z projects" - when they actually have little to no understanding of those projects or exactly how their PR works. It was (somehow) accepted and that's that.

But you REALLY need to know your stuff to begin with for they to be of any use. Those who think they will take over are clueless.

Or - there are enough people who know their stuff that the people who don't will be replaced and they will take over anyway.

It cannot, however, synthesize new facts by combining information from this corpus.

That would be like saying studying mathematics can't lead to someone discovering new things in mathematics.

Nothing would ever be "novel" if studying the existing knowledge could not lead to novel solutions.

GPT 5.2 Thinking is solving Erdős Problems that had no prior solution - with a proof.

An automated way to achieve this would be awesome.

The author can easily do this by creating a simple memory tool call, announcing it in the prompt to the LLM, and having it call the tool.

I wrote an agent harness for my own use that allows add/remove memories and the AI uses it as you would expect - to keep notes for itself between sessions.

What is wrong with "claude --chrome"?

You can do this.

At least to a level that gets you way past HTTP Bearer Token Authentication where the humans are upvoting and shilling crypto with no AI in sight (like on Moltbook at the moment).

Claude generated the statements to run against Supabase and the person getting the statements from Claude sent it to the person who vibe-coded Moltbook.

I wish I was kidding but not really - they posted about it on X.

What are we discussing here?

The tools or the models? It's getting absurdly confusing.

"Claude Code" is an interface to Claude, Cursor is an IDE (I think?! VS Code fork?), GitHub Copilot is a CLI or VS Code plugin to use with ... Claude, or GPT models, or ...

If they are using "Claude Code" that means they are using Anthropic's models - which is interesting given their huge investment in OpenAI.

But this is getting silly. People think "CoPilot" is "Microsoft's AI" which it isn't. They have OpenAI on Azure. Does Microsoft even have a fine-tuned GPT model or are they just prompting an OpenAI model for their Windows-builtins?

When you say you use CoPilot with Claude Opus people get confused. But this is what I do everyday at work.

shrug

This is great.

When I work with AI on large, tricky code bases I try to do a collaboration where it hands off things to me that may result in large number of tokens (excess tool calls, unprecise searches, verbose output, reading large files without a range specified, etc.).

This will help narrow down exactly which to still handle manually to best keep within token budgets.

Note: "yourusername" in install git clone instructions should be replaced.

The flickering issue due to the Ink library has been a headache for a long time, but they are slowly making progress on this.

https://github.com/anthropics/claude-code/issues/769

The problem is they are using the Ink library which clears and redraws for each update.

https://github.com/anthropics/claude-code/issues/769

I locally patched the closed-source CLI npm package but it's not perfect. They would have to switch how their TUI is rendered on their side.

Apparently OpenAI Codex is rust+ratatui which does not have this issue.

Claude is definitely not taking screenshots of that desktop & organizing, it's using normal file management cli tools

Are you sure about that?

Try "claude --chrome" with the CLI tool and watch what it does in the web browser.

It takes screenshots all the time to feed back into the multimodal vision and help it navigate.

It can look at the HTML or the JavaScript but Claude seems to find it "easier" to take a screenshot to find out what exactly is on the screen. Not parse the DOM.

So I don't know how Cowork does this, but there is no reason it couldn't be doing the same thing.