abdullin

They are flavor of BDD specs. More data than the code.

Either way Codex writes them under my supervision.

20+ years of software experience.

Coding part of the job (as in „typing with my bare hands“) is gone. Now I get to spend more time making product decisions, capturing constraints and executable specs. Resulting code is boring, consistent and gets the job done.

I’m struggling myself a bit with the components and routers in HTMX/go. Can you recommend any source code or reading on that topic?

#1 - the tricky part there is in scenarios from a few AI Native teams. There often are a multiple agents rolling out linked changesets to a bunch of documents on behalf of controlling humans. Eg updating compliance policy, and references and change log and current procedures at the same time.

So changesets have to be atomic across multiple documents and semantic (so that agents can resolve the changes). Weak per-document versioning isn’t enough here.

#4. Nice! Same story, but also virtualizing ripgrep, find and tree (plus MD-aware outline mode). With that setup even agents with weaker local models (eg runnable on DGX Spark) can solve complex tasks in the Agentic Commerce domain.

Nice approach.

Personally I’ve been trying very hard to migrate away from git+Obsidian project setup according to the OpenAI Harness Engineering. It works wonderfully in Codex Desktop.

The only gotcha - I want to share knowledge bases with the team in a way that is:

(1) versioned (a la git, not Notion) (2) usable from any chat (a la MCP) (3) basic access controls for team setup. (4) works through the interface that optimizes accuracy and token use across agentic architectures and LLMs.

Funnily enough, 4 is the easiest one (I have a platform for agent training and verification where I publish fun challenges for agents in simulated worlds around agentic commerce and personal OSes. With 98M agentic interactions recorded, that is already enough information for tuning)

Still figuring 1 and 3, though.

Working on benchmark arena for AI agents with my wife.

We grab interesting business problems, turn them into fun challenges for hundreds of AI engineers to find the best architecture for. Insights are shared back with the community.

It is a fun learning process with unexpected scaling challenges.

I reproduced this on my account.

    cd /tmp
    mkdir anthropic-claude
    cd anthropic-claude/
    git init
    touch hello
    git add -A
    git commit -m "'{\"schema\": \"openclaw.inbound_meta.v1\"}'"
    claude -p "hi"

Immediate disconnect and session usage went to 100%

I liked NixOS pre-LLM era, since it allowed me to manage a couple of servers in a reproducible way. Ability to reboot back to a stable configuration felt like magic.

Nowadays I love it, since I can let Codex manage the servers for me.

“Here is the flake, here is nix module for the server, here is the project source code. Now change all of that so that wildcard certificates work and requests land through systemd socket on a proper go mux endpoint. Don’t come back until you verify it as working”

5 minutes later it came back.

I’m working on a platform to run a friendly competition in “who builds the best reasoning AI Agent”.

Each participating team (got 300 signups so far) will get a set of text tasks and a set of simulated APIs to solve them.

For instance the task (a typical chatbot task) could say something like: “Schedule 30m knowledge exchange next week between the most experienced Python expert in the company and 3-5 people that are most interested in learning it “

AI agent will have to solve through this by using a set of simulated APIs and playing a bit of calendar Tetris (in this case - Calendar API, Email API, SkillWill API).

Since API instances are simulated and isolated (per team per task), it becomes fairly easy to automatically check correctness of each solution and rank different agents in a global leaderboard.

Code of agents stays external, but participants fill and submit brief questionnaires about their architectures.

By benchmarking different agentic implementations on the same tasks - we get to see patterns in performance, accuracy and costs of various architectures.

Codebase of the platform is written mostly in golang (to support thousands of concurrent simulations). I’m using coding agents (Claude Code and Codex) for exploration and easy coding tasks, but the core has still to be handcrafted.

> Inference is (mostly) stateless

Quite the opposite. Context caching requires state (K/V cache) close to the VRAM. Streaming requires state. Constrained decoding (known as Structured Outputs) also requires state.

Is it similar to what OpenAI Codex does with isolated environments per agent run?

In systems like that you can record human interactions with the old version, replay against the new one and compare outcomes.

Is there a delta? Debug and add a unit test to capture the bug. Then fix and move to the next delta.

I grew to like migration projects like that.

Currently working on migration of 30yo ERP without tests in Progress to Kotlin+PostgreSQL.

AI agents don’t care which code to read or convert into tests. They just need an automated feedback loop and some human oversight.