meander_water

Yeah I was hoping for a lot more from the title.

This is really cool and interesting timing, as I created something similar recently - https://github.com/julio-mcdulio/pmp

I've been using mlflow to store my prompts, but wanted something lightweight on the cli to version and manage prompts. I setup pmp so you can have different storage backends (file, sqlite, mlflow etc.).

I wasn't aware of dotprompt, I might build that in too.

We already have AG-UI [0], which has been implemented by frameworks like Microsoft agent framework, pydantic AI and llamaindex. I guess they'll just have to duplicate functionality.

Sigh.

[0] https://docs.ag-ui.com/introduction

I've been doing something like this for a while, and it provides decent enough results for agents to one-shot. The key is to specify the LLM with the idea, and then get it to ask you questions until you feel enough ambiguity has been eliminated from the product spec for you to pass it to an agent.

It's funny, I clicked the link to the demo, but it 404s, then I tried googling Worldgen, and it turns out someone else has built the same thing in May and called it Worldgen as well. Looks like it does better at realistic 3D scenes compared to this.

[0] https://worldgen.github.io/index.html

Here's the juicy stuff mentioned in the article: https://storage.courtlistener.com/recap/gov.uscourts.cand.43...

I've noticed this too. The latest cursor version has a @browser command which will launch a browser with playwright, and call tools to inspect the html and inject JavaScript to debug in real-time.

When it has access to the right tools, it does a decent job, especially for fixing CSS issues.

But when it can't see the artifacts it's debugging, it starts guessing, confident that it knows the root cause.

A recent example: I was building up a html element out of the DOM and exporting to PNG using html2canvas. The element was being rendered correctly in the DOM, but the exported image was incorrect, and it spent 2 hours spinning it's wheels and repeating the same fixes over and over.

I think you can compile the rust core lib from source yourself - https://github.com/Shyam20001/brahma-core

I don't get it, can't you just use yaml instead of inventing another DSL.

There's a few bits of information from the original sources that's left out:

- The METR paper surveyed just 16 developers to arrive at their conclusion. Not sure how that got past review. [0]

- The finding from the MIT report can also be viewed from a glass 5% full perspective:

> Just 5% of integrated AI pilots are extracting millions in value. > Winning startups build systems that learn from feedback (66% of executives want this), retain context (63% demand this), and customize deeply to specific workflows. They start at workflow edges with significant customization, then scale into core processes. [1]

[0] https://arxiv.org/abs/2507.09089

[1] https://mlq.ai/media/quarterly_decks/v0.1_State_of_AI_in_Bus...

> There is a user in the JavaScript community who goes around adding "backwards compatibility" to projects. They do this by adding 50 extra package dependencies to your project, which are maintained by them.

This is a spicy one, would love to know more.

Yeah I was hoping to see the actual script content

Why wouldn't you use OP's approach to build up the representative embeddings, and then train the MLP on that?

That way you can effectively handle open sets and train a more accurate MLP model.

With your approach I don't think you can get a representative list of N tweets which covers all possible categories. Even if you did, the LLM would be subject to context rot and token limits.

Agreed, I've run sentence-transformers/all-MiniLM-L6-v2 locally on CPU for a similar task, and it was approx X2 faster than calling the OpenAI embedding API, not to mention free.

Your vector store should let you store the original text as well as metadata, where you can store the version. For e.g. turbopuffer lets you filter on attributes https://turbopuffer.com/docs/query#filtering

A couple of examples I have seen recently which makes me agree with OP:

- PaddleOCR, a 0.9B model that reaches SOTA accuracy across text, tables, formulas, charts & handwriting. [0]

- A 3B and 8B model which performs HTML to json extraction at GPT-5 level accuracy at 40-80x less cost, and faster inference. [1]

I think it makes sense to fine tune when you're optimizing for a specific task.

[0] https://huggingface.co/papers/2510.14528

[1] https://www.reddit.com/r/LocalLLaMA/comments/1o8m0ti/we_buil...

> The score reported uses a minor prompt addition: "You should use tools as much as possible, ideally more than 100 times. You should also implement your own tests first before attempting the problem."

I'm not sure if the SWE benchmark score can be compared like for like with OpenAIs scores because of this.

I've not used Claude Code, so my answer might not be that useful. But I would think that because both are chat-based interfaces you would be able to instruct the model to either continue without approval or wait for your approval at each step. I certainly do that with Cursor. Cursor has also recently started automatically generating TODO lists in the background (with a tool call I'm assuming), and displaying them as part of the thinking process without explicit instruction. I find that useful.

Agree with the other commenters here that this doesn't feel like engineering.

However, Anthropic has done some cool work on model interpretability [0]. If that tool was exposed through the public API, then we could at least start to get a feedback loop going where we could compare the internal states of the model with different prompts, and try and tune them systematically.

[0] https://www.anthropic.com/research/tracing-thoughts-language...

Interesting, if you take a look at the median throughput chart [0], groq goes insane after 7th Oct. Wonder what happened.

[0] https://openrouter.ai/moonshotai/kimi-k2-0905/performance

This is built into Cursor now with plan mode https://cursor.com/docs/agent/planning

The problem with stuff like this is that it's hard to evaluate. You don't even know when the agent is using a skill, or if the skill even made a difference. Using tools lets you at least instrument tool calls, and control what gets executed.

I often need both. When I pull up a man page for a tool I haven't used before, I go to straight the bottom to look for an example that matches my use case. Once I have it, I lookup the the specific flags and what they do. Examples aren't meant to be exhaustive, but they certainly help onboard new people faster.

Great read, but I was expecting something different based on the title.

This sounds like his approach working on personal projects. I'm really curious about large technical team projects though. What's the best approach to getting stuff done and making sure everyone is working towards the same goal etc.

After 15 years I have yet to see a technical project that hasn't run over budget, over time, under delivered or burnt people out.

I'm sure there are people out there with counter examples who know exactly how to deliver projects at a massive scale. Any links/suggested reading would be appreciated!

I don't think this is a bombshell finding. Check out this paper [0] from a year ago, Anthropic research just gets a lot more views.

> Our experiments reveal that larger LLMs are significantly more susceptible to data poisoning, learning harmful behaviors from even minimal exposure to harmful data more quickly than smaller models.

[0] https://arxiv.org/html/2408.02946v4

Vibe coding has its place. I've mainly used it to create personalised ui's for tasks very specific to me. I don't write tests, I may throw it away next week but it's served its purpose at least once. Is this grossly inefficient? Probably.

I've done my share of vibe coding, and I completely agree with OP.

You just don't build up the necessary mental model of what the code does when vibing, and so although you saved time generating the code, you lose all that anyway when you hit a tricky bug and have to spend time building up the mental model to figure out what's wrong.

And saying "oh just do all the planning up front" just doesn't work in the real world where requirements change every minute.

And if you ever see anyone using "accepted lines" as a metric for developer productivity/hours saved, take it with a grain of salt.

There is nothing social about an app which auto-generates videos designed to keep you scrolling.

We are already struggling with with apps designed to steal our attention (TikTok, YouTube Reels).

I don't mean to sound like a doomer, but this can't end well.

Please ignore my first assertion that the behavior between REPL and module is different.

This would have been the case if the semantics of the original PEP649 spec had been implemented. But instead, PEP749 ensures that it is not [0]. My bad.

[0] https://peps.python.org/pep-0749/#behavior-of-the-repl

There's actually another issue with ForwardRefs. They don't work in the REPL. So this will work when run as a module:

  def foo() -> "Bar":
     return Bar()

But will throw an error if copy pasted into a REPL.

However, all of these issues should be fixed in 3.14 with PEP649 and PEP749:

> At compile time, if the definition of an object includes annotations, the Python compiler will write the expressions computing the annotations into its own function. When run, the function will return the annotations dict. The Python compiler then stores a reference to this function in __annotate__ on the object.

> This mechanism delays the evaluation of annotations expressions until the annotations are examined, which solves many circular reference problems.