afro88

I can't remember what the technique is called, but back in the GPT 4 days there was a paper published about having a number of attempts at responding to a prompt and then having a final pass where it picks the best one. I believe this is part of how the "Pro" GPT variant works, and Cursor also supports this in a way (though I'm not sure if the auto pick best one at the end is part of it - never tried)

That's not the same picture

This is an excellent article. And can I just remind everyone that this is what human authorship looks like? Clearly not LLM generated. It has the author's unique tone, take on the subject, research, clear compelling story... A real breath of fresh air to be honest.

I got a lot of <empty> as well. But was able to get a slide deck out of it before that happened, and it was reasonably good. Not 1-shot good, but better than what I have gotten out of Opus 4.6 with a skill previously

If you work with an exceptional one, sure

And India. It's a common experience that engineering teams from India will say yes to everything and then do what they think is best. Rather than saying no and explaining what they want to do instead

I believe it generates playwright scripts (non deterministically) which are saved and executed again (deterministically)

I know this was just an example, but:

> I know I wrote a good one for my git commit/push flow somewhere, but finding it when I need it usually takes longer than just rewriting it

This is actually a really good use case for a skill. Then when you go "commit and push" it'll do the right thing

This is a really nice setup for side projects and random ideas too. Thanks for sharing!

It doesn't look like they think about how to make it fit though. They just use a known good go template

Dude come on, I clearly wasn't saying LLMs are people. My point was it's a tool and it's the responsibility of the person wielding it to check outputs.

If it's too hard to check outputs, don't use the tool.

Your arguments about copyright being different for LLMs: at the moment that's still being defined legally. So for now it's an ethical concern rather than a legal one.

For what it's worth I agree that LLMs being trained on copyright material is an abuse of current human oriented copyright laws. There's no way this will just continue to happen. Megacorps aren't going to lie down if there's a piece of the pie on the table, and then there's precedent for everyone else (class action perhaps)

Same as if a regular person did the same. They are responsible for it. If you're using AI, check the code doesn't violate licenses

Yep, that is definitely a step change. Pricing is going to be wild until another lab matches it.

I use Claude Code extensively and haven't noticed this. But I don't have it doing long running complex work like OP. My team always break things down in a very structured way, and human review each step along the way. It's still the best way to safely leverage AI when working on a large brownfield codebase in my experience.

Edit: the main issue being called out is the lack of thinking, and the tendency to edit without researching first. Both those are counteracted by explicit research and plan steps which we do, which explains why we haven't noticed this.

IIUC this doesn't make the LLM think in caveman (thinking tokens). It just makes the final output show in caveman.

As a kid who spent many hours on Vista on the Amiga 500, this has blown my mind

This is a really good idea. Especially if the chunks are marked as read as you are guided through them and you can validate you've seen all the code by the end

> The cogs are part of the machine, they don't deserve any sympathy just because they chose to do bad things for money

That's a bit of a stretch saying that someone who enforces the rules around disability for a job is doing bad things for money. These same rules filter out a lot of scammers that if not stoped would mean less money going to the right people.

It's also a low skill low pay job, probably worked by a large percentage of people who are close to the poverty line and just trying to make ends meet to support a family.

What good does hating the cogs do though? Make noise to the people who can change the machine.

Sounds like me with listening to AI covers. After a couple of weeks I couldn't care less. But I was so stoked in it at the start

Because AI is way too sycophantic still. The real audio engineers I spoke to said they run into this problem maybe once every few months and even then only when working for particular clients. Too much friction to purchase one offs, not enough pain for a monthly subscription.

https://claude.ai/share/be61468f-9f38-4dc0-aae3-5d758bf0f200

I vibe coded a saas and it went nowhere because it wasn't a good enough idea to begin with. I consulted with multiple varied models along the way for competitive analysis, pricing structure etc.

AI doesn't solve for ideas and product market fit. But it did allow me to fail pretty fast before I sunk too much time into it. But also, I should have spoken to potential users earlier rather than vibe coding.

That's what I was getting at. With the review and potential rework time, we could be looking at over the original 4 week estimate. So then what's the point in using long running unsupervised agents if it ends up being longer than doing it in small chunks.

It's a nice idea, but how do you know the agent is aligned with what it thinks the intent is?

Oh I didn't mean literally how do I review code. I meant, if an agent can write a lot of code to achieve a large task that seemingly works (from manual testing), what's the point if we haven't really solved code review? There's still that bottleneck no matter how fast you can get working code down.

Good idea, and an improvement, but you still have that fundamental issue: you don't really know what code has been written. You don't know the refactors are right, in alignment with existing patterns etc.

I guess to reach this point you have already decided you don't care what the code looks like.

Something I'm starting to struggle with is when agents can now do longer and more complex tasks, how do you review all the code?

Last week I did about 4 weeks of work over 2 days first with long running agents working against plans and checklists, then smaller task clean ups, bugfixes and refactors. But all this code needs to be reviewed by myself and members from my team. How do we do this properly? It's like 20k of line changes over 30-40 commits. There's no proper solution to this problem yet.

One solution is to start from scratch again, using this branch as a reference, to reimplement in smaller PRs. I'm not sure this would actually save time overall though.

Will you get rid of him? It sounds like he's wasting a lot of your time

I wouldn't have picked this article as AI until I got an agent to do some writing for me and read a bunch of it to figure out if I can stand behind it. Now I see the tells everywhere "It's not this. It's that." is particularly common and I can't unsee it. (FWIW I rewrote most of the writing it generated, but it did help me figure out my structure and narrative)

The problem I think with AI generated posts is that you feel like you can't trust the content once it's AI. It could be partly hallucinated, or misrepresented.

This is exactly right IMO. I have never worked for a company where the bottleneck was "we've run out of things to do". That said, plenty of companies run out of actual software engineering work when their product isn't competitive. But it usually isn't competitive because they haven't been able to move fast enough