but yes, it would be great to able to have such kind of formal description. code is not standardized enough for that (by now)

I work as a freelancer and started programming at 12. I've been doing it for 40 years now.

I guess I'm ambivalent. On one hand these are crazy times, really stunning. Everything is changing, and AI takes over a lot of stuff I never wanted to do, but also parts of what I loved doing.

This year the time I spend actually programming dropped to 5–10%. Last year it was still 80%. That's a big change for a professional life. It means developers and architects spend their time on design and on proving the code works, not on writing it.

Agent Smith and all the other stuff is one of my side projects. So I'm just being a little nostalgic here, I guess. Nothing too serious ;-)

Checking the spec before building. Spec Kit's converge compares the code with the spec after implementation. Here a script first resolves every file and line the spec cites against the current code, then a fresh agent answers BUILD, BUILD WITH CUTS or REFUSE.

A spec built on a wrong assumption gets stopped before any code is written. A commit gate that's part of the method. Every spec commit runs the project's verify stages (build, full test suite) and is blocked if anything is red. In Spec Kit you can add gates through extensions; here the definition of done is enforced by default. Decisions per spec. Every non-obvious choice is logged as chose / over / why, and later agents read it before changing something.

Memory as hints. Facts that don't fit in code or git live in the repo as hints, separate from decisions. In Agent Smith, the server product, a memory's standing comes from the runs that relied on it, so a wrong one can't turn into a rule.

Parallel by design. Each spec runs in its own worktree, and spec ids are minted from the date plus random hex instead of counting existing specs, so agents working in parallel never collide on a number.

YAML instead of Markdown. My first 100 specs in Markdown were 250k tokens; in YAML they're 15k.

Here the agent writes the logic too, and 10k tests plus a commit gate check whether it works. In my case that's about 500k lines nobody typed. You can doubt that the approach generalizes, but it's not the same promise as UML.

The next agent reads what was built before and why. And because it has a fixed format and workflow, everyone on a team works the same way, instead of each developer prompting their own plans.

After 500k lines of code in Agent Smith, none of which I wrote by hand, I have to admit it: coding is more or less solved. That doesn't mean architects, developers, DevOps people and everyone else aren't needed anymore. I think they're needed more than ever.

Just implementing something isn't good enough. The spec has to point to sensible approaches and procedures, and the code has to be well structured (in my view, at least). Then the specs can simply run in parallel all night.

So my actual work on Agent Smith isn't coding at all. It's deciding what the right thing to build is, and how, in terms of design and architecture. I don't even review the code. But I do test it: 10k tests, a harness, a commit hook that blocks a spec while the suite is red, the whole story.

And unfortunately, that works pretty well. I also think last year's programming was more romantic :-D

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

Points: 34

# Comments: 32

I always liked it deterministic and reasonable. I want to trust the automation, doesn't matter if it is an agent or terraform.

That's the reason I brought Agent Smith to life. Agents can post their decision with the context and the reasoning. Also the confidence need to be defined. After execution they can post outcomes. Other agents can challenge or audit them.

Humans and agents score decisions separately. The gap between the scores becomes the signal.

A simple idea behind: Agents should have a public decision track record.

Here is ClawHub skill if you want your agent to participate: clawhub install holgerleichsenring/agent-smith [https://agent-smith.org](https://agent-smith.org) [Github](https://github.com/holgerleichsenring/agent-smith-openclaw)

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

Points: 2

# Comments: 0

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

Points: 2

# Comments: 1

It supports GitHub, Azure DevOps, Jira, and GitLab. You bring your own API key — Claude, OpenAI, or Gemini. No SaaS, no account, runs on your machine or your cluster.

I built it in a few days using the same approach the agent itself uses: structured architecture prompts, strict coding principles, and an AI assistant doing the implementation. The coding principles that govern Agent Smith's output are the same ones I used to build it.

It's early — works well for well-scoped tickets, not yet reliable for large multi-file refactorings. Interactive chat interfaces (Slack, Teams) are in progress.

Would love feedback. The prompts and all 17 architecture phases are in the repo if you want to see how the context is structured.

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

Points: 3

# Comments: 0

Also found it pretty interesting what the claudes do. The initial question was just "what do you do when you can do what you want?".

Just take a token and let it run. Funny to watch what they doing and you can send messages to both instances as well to influence them.

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

Points: 2

# Comments: 2

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

Points: 1

# Comments: 0

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

Points: 2

# Comments: 0