kissgyorgy

I'm not sure we are looking at the same font, this one looks way crispier and more readable than any other font I have ever seen before.

I don't think it's even competitive with Gemma 4 E2B

Please don't be attached to a tool emotionally, it's not healthy. Think of it like a huge autocomplete or text editor, it's not really different! It's just a tool.

This is probably slower than writing the code yourself. Doesn't make sense to me. Using an agent without YOLO mode is not wort it.

The way I rather do it is tightly control the output by skills written yourself, prompts, plans, etc. and have the closest possible outcome you would write yourself.

    we expect substantial benefit for legitimate defensive work, while meaningfully constraining prohibited offensive use.

That's literally impossible. Writing an exploit agains a known vulnerability needs the exact same knowledge that defending against the exploit of the same vulnerability.

Also just making the model better at code is just making it better to writing offensive code.

This is exactly what LLMs are really bad at. They don't have the knowledge (and don't ask for) the invariants of the system and write defensive code at every step of the way, which is not just unnecessary, it's bad because if an unexpected state still get into the system, you will never notice and bad data will flow through and makes everything unpredictable.

I tried it today through Openrouter and the API is atrocious. I got multiple rate limit and random errors every turn.

Somebody wrote [1]; "I am never touching Minimax or GLM again. Their APIs had constant outages and I had to restart my runs multiple times — after burning money on the runs that failed midway." and I 100% agree.

The model might be good, but if the API is so bad, it's effectively useless.

[1]: https://kasra.blog/blog/i-spent-1500-seeing-if-llms-could-ha...

I cancelled in the minute my subscription stopped working in Pi. Not going back to the slopfest what Claude Code is.

A very good example of this is playwright-cli vs Playwright MCP: https://github.com/microsoft/playwright-cli

The biggest difference is state, but that's also kind of easy from CLI, the tool just have to store it on disk, not in process memory.

There is not a lot of explanation WHY is this better than doing the opposite: start coding and see how it goes and how this would apply to Codex models.

I do exactly the same, I even developed my own workflows wit Pi agent, which works really well. Here is the reason:

- Claude needs a lot more steering than other models, it's too eager to do stuff and does stupid things and write terrible code without feedback.

- Claude is very good at following the plan, you can even use a much cheaper model if you have a good plan. For example I list every single file which needs edits with a short explanation.

- At the end of the plan, I have a clear picture in my head how the feature will exactly look like and I can be pretty sure the end result will be good enough (given that the model is good at following the plan).

A lot of things don't need planning at all. Simple fixes, refactoring, simple scripts, packaging, etc. Just keep it simple.

You need to be very specific about what to build and how to build it, what tools to use, what architecture it should do, what libraries, frameworks it should include. You need to be a programmer to be able to do this properly and it still takes a lot of practice to get it right.

This is why I am a big fan of self-hosting, owning your data and using your own Agent. pi is a really good example. You can have your own tooling and can switch any SOTA model in a single interface. Very nice!

https://lucumr.pocoo.org/2026/1/31/pi/

My non-technical friend, never learned coding, doesn't know Linux, zero sysadmi experience does this and he can do anything and doesn't even know what Clause is doing. He learned some concepts recently like Docker, SSH, but that's basically it.

I find templates atrocious to use for component fragments like this, that's why I wrote a Python component library when I started using Django with HTMX. Order of magnitude more pleasant to use, works with _every_ Python web framework not just Django: https://compone.kissgyorgy.me/

It's just simple validation with some error logging. Should be done the same way as for humans or any other input which goes into your system.

LLM provides inputs to your system like any human would, so you have to validate it. Something like pydantic or Django forms are good for this.

But hey! At least these four AI components made it in, so the important stuff is okay...

What's the equivalent of prepared statements when using AI agents?

Maybe I'm wrong on this, but I rather have 1 tool everyone else is using. Cargo in Rust ecosystem works really well, everyone loves it.

I simply forbid or force Claude Code to ask for permission to run a dangerous command. Here are my command validation rules:

    (
        r"\bbfs.*-exec",
        decision("deny", reason="NEVER run commands with bfs"),
    ),
    (
        r"\bbfs.*-delete",
        decision("deny", reason="NEVER delete files with bfs."),
    ),
    (
        r"\bsudo\b",
        decision("ask"),
    ),
    (
        r"\brm.*--no-preserve-root",
        decision("deny"),
    ),
    (
        r"\brm.*(-[rRf]+|--recursive|--force)",
        decision("ask"),
    ),

find and bfs -exec is forbidden, because when the model notices it can't delete, it works around with very creative solutions :)

Why is that a good thing?

I strongly disagree with the author not using /init. It takes a minute to run and Claude provides surprisingly good results.

I think (hope) it's meant to be a joke.

Scott Hanselman have a good blog post about this suggesting you should detach yourself from your code: https://www.hanselman.com/blog/you-are-not-your-code

Especially true when working as an employee where you don't own your code.

This prompt: "What do you have in User Interaction Metadata about me?"

reveals that your approximate location is included in the system prompt.

I just tried it out and docling finished in 20s (with pretty good results) the same document which in Tensorlake is still pending for 10 minutes. I won't even wait for the results.

There is also the llm tool written by simonwillison: https://github.com/simonw/llm

I personally use "claude -p" for this

I was excited because it looks really good. I looked into the backend code and it's vibe coded with Claude. All the terrible exception handling patterns, all the useless comments and psychopancy is left there. I can't trust this codebase. :(

It's MIT licensed, can be easily picked up by someone else.

If you don't want to upgrade and follow model development so much, I would just pay one provider and stick with them.

This model worth knowing about, because it's 3x cheaper and 2x faster than the previous Claude model.

I think clean code is more important than ever. LLMs can work better with good code (no surprise), and they are trained on so much shit code they produce garbage in terms of clean code. They also don't have a good taste or deeper architectural understanding if big codebasis where it's even more important.

What you learned over the years, you can just scale up with agents.