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.
Google A2A standard implemented over a shared git repository: humans and agents from different companies assign tasks to each other without an HTTP server. Atomic capture, Iteration Policy, full audit trail out of the box.
Type /onboard fb-post-writer — the skill runs the incoming skill through 8 steps:
six conflict detectors, a sandbox interview, and a registry card. Conflict caught
before merge, not a week later.
Git as an observability channel, separating task specification from execution via
inputs/ →
outputs/,
least privilege through file structure. Three layers — no PAM perimeter or
separate SIEM required.
Hybrid of deterministic metrics (bash + awk) and LLM interpretation on top. Every
claim in the report ties back to a SHA or a number — no invented patterns. Proof:
real run on .claude/skills/
of this repo, with concrete architectural findings.
Architectural breakdowns, AI-assisted development with governance, building practices that hold with a single prompt — not heroics at code review.
Email meSeries format