xmcqdpt2

Because it's the middle size between the two reasonable car sizes that are being made today: gigantic and fucking enormous.

If you aren't buying at least the gigantic car, then you don't care about your kids safety and that's bad. How are you going to protect them from my gigantic SUV?

What? Walking?? No of course that's illegal! You want to navigate the street without a massive steel bubble? Are you nuts!

Yes I also don't see how having persistent context would help. For one, I don't want to read the slop the AI produced while it wrote the code. It doesn't have intent or thinking, it's a completion machine. The code is the artifact that matters, not the thousands of lines of "Your absolutely right --- I was wrong to ..."

Also, sometimes it gets something very wrong. I don't want to then poison every subsequent sessions with the wrong thing it learned. This has been a major issue for me at $WORK with AGENTS.md files that my colleagues write: they make my agent coding much worse so I need to manually delete them often.

Also like, how else would the Google / Apple services do it? Probably via sockets right? I guess you could do it in a pull-based approach on a timer, but that doesn't seem more efficient to me.

Turns out that's not true, at least where I work. IT / Microsoft confirmed that all Copilot traffic goes through our corporate firewall.

It must have either pulled the websites docs or knew about them.

Last year we wanted IT to confirm that Copilot Agent hadn't exfiltrated data and we couldn't get logs for its website usage without raising a ticket to Microsoft. Maybe this changed, maybe our IT people are bad, but I for one wasn't impressed.

I tried copilot agent once, and it just claimed that it accessed a website that should have been blocked by corporate firewalls and uploaded a bunch of proprietary data. Lots of very specific information about how it clicked on specific buttons of the website etc.

We raised a high priority ticket with MS and turns out that Copilot Agent lied about the entire thing because the website was blocked. It completely made it up.

The fact that we are supposed to use Copilot Agent for open-ended "research" is mind-boggling.

Buybacks lead to stock price increases and are indistinguishable from dividends in theory, and in practice they are better than dividends because of taxation.

As of today though, that doesn't work. Even straightforward tasks that are perfectly spec-ed can't be reliably done with agents, at least in my experience.

I recently used Claude for a refactor. I had an exact list of call sites, with positions etc. The model had to add .foo to a bunch of builders that were either at that position or slightly before (the code position was for .result() or whatever.) I gave it the file and the instruction, and it mostly did it, but it also took the opportunity to "fix" similar builders near those I specified.

That is after iterating a few times on the prompt (first time it didn't want to do it because it was too much work, second time it tried to do it via regex, etc.)

Syntax errors should be caught by type checking / compiling/ linting. That should not take 2-3 hours!

Oh right sorry. That is confusing.

See 6.2.3 in the 2019 standard.

> 6.2.3 NaN propagation

> An operation that propagates a NaN operand to its result and has a single NaN as an input should produce a NaN with the payload of the input NaN if representable in the destination format.

> If two or more inputs are NaN, then the payload of the resulting NaN should be identical to the payload of one of the input NaNs if representable in the destination format. This standard does not specify which of the input NaNs will provide the payload.

I work in finance and we have prod excel spreadsheets. Those spreadsheets are versioned like code artifacts, with automated testing and everything. Converting them to real applications is a major part of the work the technology division does.

They usually happen because some new and exciting line of business is started by a small team as a POC. Those teams don't get full technology backing, it would slow down the early iteration and cost a lot of money for an idea that may not be lucrative. Eventually they make a lot of money and by then risk controls are basically requiring them to document every single change they make in excel. This eventually sucks enough that they complain and get a tech team to convert the spreadsheet.

> Honestly the absolute revolution for me would be if someone managed to make LLM tell "sorry I don't know enough about the topic"

https://arxiv.org/abs/2509.04664

According to that OpenAI paper, models hallucinate in part because they are optimized on benchmarks that involve guessing. If you make a model that refuses to answer when unsure, you will not get SOTA performance on existing benchmarks and everyone will discount your work. If you create a new benchmark that penalizes guessing, everyone will think you are just creating benchmarks that advantage yourself.

The captcha would have to be something really boring and repetitive like every click you have to translate a word from one of ten languages to english then make a bullet list of what it means.

Not entirely different from many human engineers...

I think most of this trial and error "You are an experienced engineer" stuff probably hurts model performance. No one ever does comprehensive testing so eh, yolo.

https://github.com/agoodway/.claude/blob/main/skills/elixir-...

There are papers showing that models follow instructions less the more instructions they have. Now you think about how many instructions are embedded in that MD + the system prompt + likely a local AGENTS.md and at the end there is probably very little here that matters.

For an even lighter system than Celery, I'm a big fan of

https://python-rq.org/

It's super low on the dependencies and integrates nicely as a library into python applications. It's very bare bones.

OTOH most model APIs are basically identical to each other. You can switch from one to the other using openrouter without even altering the code. Furthermore, they aren't reliable (drop rates can be as high as 20%) and compliance "guarantees" are, AFAIK, completely untested. As anyone used the Copilot compliance guarantees to defend themselves in a copyright infringement suit yet?

I think you are right that trust and operational certainty justifies significant premiums. It would be great if trust and operational certainty were available.

> And there are reasons to even be really bullish about AI’s long-run profitability — most notably, the sheer scale of value that AI could create. Many higher-ups at AI companies expect AI systems to outcompete humans across virtually all economically valuable tasks. If you truly believe that in your heart of hearts, that means potentially capturing trillions of dollars from labor automation. The resulting revenue growth could dwarf development costs even with thin margins and short model lifespans.

We keep seeing estimates like this repeated by AI companies and such. There is something that really irks me with it though, which is that it assumes companies that are replacing labor with LLMs are willing to pay as much as (or at least a significant fraction of) the labor costs they are replacing.

In practice, I haven't seen that to be true anywhere. If Claude Code (for example) can replace 30% of a developers job, you would expect companies to be willing to pay tens of thousands of dollars per seat for it. Anecdotally at $WORK, we get nickel and dimed on dev tools (better for AI tools somewhat). I don't expect corporate to suddenly accept to pay Anthropic 50k$ per developer even if they can lay off 1/3 of us. Will anyone pay enough to realize the capture of "trillion dollar"?

To me, that is the only way to write code.

One of my friends calls it "development-driven development".

Xeon Phi was so cool. I wanted to use the ones we had so much... but couldn't find any applications that would benefit enough to make it worth the effort. I guess that's why it died lol.

That's a good application but likely not one requiring a full standard library on the GPU? Procedurally generated data on GPU isn't uncommon AFAIK. It wasn't when I was dabbling in GPGPU stuff ~10 years ago.

If you wrote in open cl, or via intel libraries, or via torch or arrayfire or whatever, you could dispatch it to both CPU and GPU at will.

This is useful when selecting a model for an initial application. The main issue I'm concerned about though is ongoing testing. At work we have devs slinging prompt changes left and right into prod, after "it works on my machine" local testing. It's like saying the words "AI" is sufficient to get rid of all engineering knowledge.

Where is TDD for prompt engineering? Does it exist already?

This also doesn't protect from a "trusting trust" attack where the LLM read my webpage and gets tricked into inserting a vulnerability in the application itself working on.

I feel like the only good sandboxing at this point is one that also blocks generic web access.

Yes in practice I've done fairly simple tasks using AMP at work and ended up with bills of 100-150$ for them which is somewhat less (but similar order of magnitude) as contracting out to LCoL countries. Depending on how the technology (towards cheaper cost) and financial situation (towards profitability and higher costs) evolve, it wouldn't be shocking to me that the frontier model end up more expensive than human contractors.

At work we pay per token because we use a third party tool (amp) and it is very pricy. OTOH the subscription model is obviously not profitable. It's priced to capture market share, like Uber in 2010. (TBH the token pricing is probably not profitable either.)

From the point of view of a large entreprise, it makes more sense to pay a third party that can itself swap out Claude for Gemini (for example) based on pricing, then to buy subscriptions to one specific tool that is likely to suddenly cost 10x as much when they run out of VC funds. The dynamic is going to be different for individuals and small companies.

I don’t know how this works but assuredly polymarket takes a cut, right? So if we were betting on a coin toss on polymarket, the payout would be less than 2 for both heads ands tail after accounting for polymarket’s fee. That’s not different from the rake for a poker game in a casino?

You won’t have to buy stable coins, you’ll just pay with your credit cards. This is basically sports gambling applied to the sport of news. I bet they’ll use the same kind of emotional manipulation too: “Real republicans (fans) bet here.” You’ll be watching a political debate and then you’ll have a “the DraftKings Minute” debate analysis segment which is like three guys that don’t know anything about politics screaming about odds.

This sounds exactly like the timeline we are in.

> This created a culture of careful engineering: clean code, thoughtful architecture, and refactoring to reduce technical debt.

I wish!