You Had Breakfast

AI in the hands of effort-obsessed thinkers is a catastrophe. They will debate everything except the one thing that matters: the problem is solved.

When people judge AI work mainly by the effort behind it, they often miss the client’s actual outcome. Not because they use the tools poorly, but because they judge the work by effort instead of usefulness. They locate value in how much personal experience you invested, how much suffering you endured, and whether you followed the correct ritual. The result becomes secondary.

This is not just a preference; it changes how they evaluate work: attention has shifted from the solved problem to the process of applying effort, and to the evaluation of whether enough visible effort was involved.

Continue reading “You Had Breakfast”

Two Measures of Imperfection: The Engineer, the Humanist, and One Shared AI

An engineer watches a humanist accept a flawed AI output and sees professional negligence. They are both right — they are just solving different problems.

Watch a developer look at a humanities person who just got a text from a neural network and is genuinely happy with it. The look carries a question the engineer will never say out loud: "Why do you let yourself be this imperfect?" The model got two facts wrong, blurred a third, and the person across the table is smiling and taking the result to work. For the engineer, this is not joy — it is professional incompetence that someone is somehow unashamed to display.

The scene is uncomfortable because the developer and the humanities worker judge the output by different standards. One treats the answer as a product to verify; the other treats it as material for further thinking.

Continue reading “Two Measures of Imperfection: The Engineer, the Humanist, and One Shared AI”

Why Your CLAUDE.md Became a Dumping Ground and How to Fix It

A 500-line CLAUDE.md is not a sign of discipline. It is an architectural anti-pattern that degrades your agent’s attention on every single task.

Some published agent prompt templates from AI vendors already run to hundreds of lines: voice tone, code review procedures, reactions to conflicting requirements, response formatting, what to do if the user is rude. The problem is visible even in mature engineering teams. Even teams close to model development often rely on long behavioral prompts. If even the creators of the agent cannot hold its behavior in twenty lines and instead write hundreds, the problem might not be the discipline of the team that created a 500-line CLAUDE.md. The file format encourages unrelated rules to accumulate in one place.

Continue reading “Why Your CLAUDE.md Became a Dumping Ground and How to Fix It”

How to Validate Project Requirements Before Handing Them to an AI Agent

AI agents read requirements literally. If your spec has gaps, the agent hallucinates the missing context and builds architecture around a guess. Here is how to build a clarify gate.

A human developer gets a ticket saying "speed up the catalog" and goes asking. In the hallway, in DMs, at the daily. They fill in the blanks: they know the catalog runs on PostgreSQL, that the last import broke, and that "speed up" in this company means p99, not average. Half the requirements are reconstructed from the team's domain experience, and nobody even notices.

An AI agent gets the same ticket and starts writing code. It doesn't fill in the blanks. It reads literally.

Three weeks later, the retrospective produces "AI can't handle architecture." That's false. It handled exactly what was written down.

Continue reading “How to Validate Project Requirements Before Handing Them to an AI Agent”

What AI Does While You Look Away: Guardrails and Harness

An LLM is a probabilistic component. The model will err. The engineering task is ensuring that error stays an error of the model, not a product incident.

An agent sends an email with order details to the wrong recipient. Another generates a destructive SQL query against the production database — because a "delete command example" was sitting in the text of the ticket it was reading. A third pulls a fragment of an internal document through RAG, complete with a secret token, and hands it to the user.

These failure modes show up when agents get write access to email, databases, or internal knowledge bases. In each case, the model produced a syntactically valid action; the system failed to constrain its consequences. Each operated correctly — a valid tool call, a well-formed SQL query, a relevant fragment from the knowledge base. The incident came from missing authorization, validation, or data-leak controls around the model output.

Assume the model will sometimes misread context, follow injected instructions, or choose a harmful tool call. The engineering task is ensuring that error stays an error of the model, not a production incident. When you first connect to an LLM API, it feels like a finished system. It isn't. A production AI deployment needs infrastructure for authorization, validation, logging, evals, rollback, and monitoring, and it rests on two layers: guardrails and harness.

Continue reading “What AI Does While You Look Away: Guardrails and Harness”

How to Build an AI Stakeholder Alignment Machine

Alignment isn’t a conversation, it’s a dispatch algorithm. Here’s how to build a multi-agent system that routes questions, resolves conflicts by seniority, and gives you a counter that hits zero.

Alignment looks like a conversation. It isn't. It's a dispatch algorithm — routing traffic between people until a set of open questions hits zero. Humans have been running this algorithm manually for decades, badly, because there was nobody to hand it to. Now there is.

What follows is a construction of several agents and tools that drive project alignment without you in the loop: it finds holes in the spec, routes questions to people through channels they actually use, processes answers, resolves contradictions by seniority, and stops either at zero open questions or at an escalation to a human. Stakeholders, adjacent teams, contractors — the mechanics don't change.

Continue reading “How to Build an AI Stakeholder Alignment Machine”

The Employment Theater of AI Code Review

3 AM. A senior developer stares at the monitor, eyes red. On screen: a massive diff. The AI generated five hundred lines of code in three seconds. Now our hero is spending half an hour reading every single line — checking brackets, variable names, indentation. In their head: "This is real engineering work."

From the outside — surrealist tragicomedy: the AI spent a moment, the human spent thirty minutes reading the output. Meanwhile, this same developer refused to spend five minutes before running the model to write clear acceptance criteria, boundary conditions, and an automated test that would verify the code in milliseconds.

The pattern is everywhere.

Continue reading “The Employment Theater of AI Code Review”

The core role of people in software development is over

Try getting a development team to consistently write tests before every commit. Not "agree in principle" — actually do it, without reminders. Or document their code. Or have a senior engineer support code three juniors wrote six months ago.

If you've never managed developers, this sounds like a process problem. If you have — you understand why what I'm about to describe doesn't surprise me anymore.


Continue reading “The core role of people in software development is over”

Hide and protect your AWS S3 endpoint (Rails+Nginx example)

It is very simple to use S3 as a storage for your static content in Rails application. Just add paperclip and aws-sdk gems. But what to do if you want to hide the direct links to S3 items, or even restrict access to some files by user’s roles and access rights? Here is a working example: Continue reading “Hide and protect your AWS S3 endpoint (Rails+Nginx example)”

Conditional GET for lists (nice trick)

Here is the nice trick to achieve Conditional GET request for lists (Index operation in classic REST terms). You know about this mechanism for single items (show operation): browser asks a resource for the first time, cache it’s last_modified value, and send “If-Modified-Since” header in the next request. A server checks database for resorce.update_at value, and responds “200 OK” with content as usual (if resource is newer), or responds with “304” without content if resource was not changed.

You can see an economy for computing resources, traffic, parsing and so on. But how to implement this technique for lists? Where is no “updated_at” attribute for the lists…

But don’t give up! Just get a newer resourse in the list, and use it’s “updated_at” attribute.

Here is an example for Ruby on Rails:
updated_at = models.max_by(&:updated_at).try(:updated_at) || Time.at(1)

The last part is a trick for empty lists. Easy!

Caveats: it will not work when you destroy a model from collection by real deleting from the database, because the newer “updated_at” value will not change or even becomes early. Browser will not get actual (changed) content. Use Paranoid gem (or mark it as something like ‘is_deleted’) instead, or switch to ETag.