Engineering breakdowns
One format throughout: real engineering task → methodology → working artifact (repo, video) → honest breakdown of where it fails. Mechanics you can repeat, and the boundary where they stop working.
Series signature
«Where it breaks» is a required section in every breakdown. An artifact without honest failure modes is a demo, not engineering.
Ask for 'ERP integration' → agent outputs an FTP-based file exchange. The root isn't the model — it's missing domain context. Grounding the agent on an authoritative book via a wiki substrate.
Cross-org contract negotiation by agents: two bots from different companies produce an OpenAPI spec themselves — humans out of the discussion loop.
Vector-only misses terms absent from the embedding. A retrieval layer with three modes for agentive book-as-context: the agent sees where each chunk came from — and can explain why it picked it.
A naive MCP server blocks on long operations. Async job queue: submit → poll, and 404-after-completion as a deliberate stateless trade-off.
The agent reuses an existing workflow — not regenerating the implementation from scratch. Same workflow_id, same processing graph, same result. Automation you can verify and reproduce.
Built at a corporate training session as a direct answer to the 'vibe-coding isn't for serious systems' skepticism. Full MLOps stack with feature store and observability. Participants examine not just what was built, but where it breaks.
When 10 people vibe-code, architectural standards drift. Governance introduced not through a lecture, but as a guardrail directly in the toolchain.
'Build an event-tracker' — an underspecified task. Two repos: UDP fire-and-forget and HTTP+PostgreSQL. The choice between them is the durability conversation.
'Sent to Kafka and forgot' — works until the first failure. It's a distributed commit with phases, and dual write without outbox is a deferred incident.
An AI feature passes eval and breaks in prod — because eval ran on the same inputs as the demo. Three release gate layers: regression from real incidents, distribution diff against a snapshot, human spot-check before deploy.
Estimation with half the requirements leads to a wrong estimate. Three context layers (domain bible, corpus, Jira graph) and a clarify bot that closes open questions before a ticket moves to sprint.
Naive vibe-coding: one big prompt → agent writes code → an hour later the structure is unclear and rollback is expensive. Spec-Driven Development reverses the order: specify → clarify → plan → tasks → implement.
A network firewall doesn't read payload semantics. An agent can forward customer PII or internal API keys in its messages. A local privacy-filter model (1.5B params, 50M active MoE) blocks leaks before text leaves — with audit trail.
Architectural breakdowns, AI-assisted development with governance, building practices that hold with a single prompt — not heroics at code review.
Email meSeries format