https://dozenal.xyz

It’s still an MVP so feedback extremely welcome!

> you still see improvements

This is expected if they are training their models on it, right?

> objectively-bad results

Keen to learn when this has been the case, i.e. across version increments in major models.

There is![0]

[0] - https://news.ycombinator.com/item?id=10178989

AGENTS.md allow you to define shared conventions in your codebase. But, just as with humans, relying on an agent to modulate its ability to respect all the various, nebulous rules and convention-based ideals in a codebase -- all by itself -- is not always effective. Most of the time, declared agent rules work, but often I will realise that a piece of work either regresses on one metric I'm trying to control for, or will forget to take into account another.

What I have tended to do in my own work in the past is to create a "script-cupboard" of checks, but it is often unwieldy and cumbersome to do this on things that require the AST or need to do awkward, large-scale string matching. These are things that existing linters and code analysis tools don't tend to support, such as mandating `package.json` dependencies in a workspace only reference a catalog.

One of the areas that agents excel at is doing exactly the above -- creating complex, arbitrary rules that can serve as deterministic guardrails for repository convention alignment. So I set out to create a library that makes it easy to instantiate such rules in any TypeScript / Bun workspace going forward.

Pokayoke is the result. I'm very keen to know what other people are using to solve this particular problem and am open to any and all feedback!

Thanks!

Comments URL: https://news.ycombinator.com/item?id=48444644

Points: 3

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=48355094

Points: 5

# Comments: 0

I like to think of it as a normal distribution, the further away a programmer is to the right of the mean, the more their benefit. It's almost like it's their standard deviation squared (σ²). So someone like Matt Perry (as OP mentioned), who is a >99.99% programmer for argument's sake and is therefore four standard deviations away from the mean... Matt gets a (4×4) 16x multiplying effect on their productivity.

Someone who is a slightly above average programmer might see a 2 or 3x boost on their productivity, which is huge(!) and might also make them fear for their job. Which tracks with the level of moral panic we are seeing and experiencing. This math kinda still holds up for "bad programmers" too (i.e. left of the mean), as in they still see a boost to their productivity (negative squared is a positive number)... but there's something iffy about their results. The technical debt is unmaintainable and because they don't _understand_ the systems that they're operating in, they end up in the "3 hour" prompt loops that the OP refers to.

> Similarly, if Matt Perry handed me the keys to the Motion repository and told me to take over, I wouldn’t have the same results even though I have access to the same set of LLM tools.

The question is -- how long is this multiplier going to exist for? Some people would wager "for the foreseeable long-term future"; some people think it will widen further; and some people think it will diminish or god forbid even collapse. It feels like most arguments at the moment (like this article's) are that the humans who "know what they are doing" will be able to baton the hatches and avoid being usurped by ever-capable models. I saw it in a café yesterday: someone was using a coding agent to build a marketing website for their project, getting more and more frustrated by not getting the outcome they wanted. Their friend typed a couple of sentences on their keyboard and got a "Dude! How did you do that? That was sick!" a minute or so later. "I used to build websites" the friend said. -- The friend 'knew what they were doing'.

How much longer is knowing what you're doing going to be a moat?

https://koomen.dev/essays/horseless-carriages/

Which way is it going to go?

i) “Seniors” also get superseded by even more capable models that can do all of the things which currently require experience.

ii) Linguistics become the new higher order abstraction (English is the new high-level programming language) _but_ there are different / orthogonal ways of approaching software development than the way we do things now — which “juniors” become more adept at more quickly.

Comments URL: https://news.ycombinator.com/item?id=48106345

Points: 18

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=48021891

Points: 1

# Comments: 0

> if/how hard it’d be to get it to pass Bun’s test suite and be maintainable

Every month brings new opportunities to completely abstract the process of porting code with agents, all using linguistics. What an exciting time.

For those looking for a similarly interesting (and interestingly similar) example, see Cloudflare's port of Next.js[0], "vinext", from a couple of months ago. It had some teething problems at the start but I'm using it in a few production projects now with minimal issues.

[0] - https://github.com/cloudflare/vinext

However, models are now getting to the point where we are starting to learn the bitter lesson[0] even with stuff like color-palette generation. Nano Banana 2 [gemini-3.1-flash-image-preview] especially is adept at performing arbitrary operations on images. Before then, you would have to use a model such as Gemini Flash to perform segmentation[1] and then post-analyze those segments.

Here's a prompt I used with Nano Banana 2 in AI Studio

> Derive a coherent, designer's color palette from this image alone.

> Provide 5 distinct HEX color codes as your response.

[Attachment == the picture of the car, first in the author's article] [Settings: Output .. images & text; Thinking level .. minimal]

Response:

> I have extracted five distinct hex color codes directly from the key elements in this image, representing the colorful facade and the vintage car:

> #FF96C5 (The main pink wall)

> #38C6F1 (The light blue car)

> #AEF6A5 (The green wall)

> #E51988 (The dark pink trim and railing)

> #5F432B (The dark wood of the door and windows)

And they all pretty-much check out. Not hyper-accurate, but really not far off anymore. I didn't even have to try!

[0] - https://en.wikipedia.org/wiki/Bitter_lesson [1] - https://ai.google.dev/gemini-api/docs/image-understanding#se...

It's definitely an interesting application of LLMs, the output text to me reads very GPT-ey, with the punctuated and concise phrasing.

Maybe(?) from a product catalogue perspective... But from a strategic perspective less so because they own ~27% of OpenAI.[0]

[0] - https://openai.com/index/next-chapter-of-microsoft-openai-pa...

I built something similar[0] a few months ago but haven't maintained it because Codex UI and Cursor have _reasonable_ tooling for this themselves now IMO.

That said there is still a way to go, and space for something with more comprehensive interactivity + comparison.

[0] - https://magiceyes.dev/