AI engineering

"Used AI" is on every CV now and means nothing. What I actually have is an engineering practice built around agents — a repeatable way of turning an LLM into a reliable collaborator on production code, with the same rigor I would apply to any other part of the stack. The difference shows up in three places: the tooling I have authored, the discipline I hold the agent to, and the fact that you are reading a page a fleet of agent sessions wrote.

I did not adopt someone else's agent workflow — I built my own and use it daily.

• A four-role skill workflow — plan → tech-spec → develop → review — plus merge-prep, handoff, lessons and session-start skills, so an agent enters every task with the right context and leaves it with the record updated. Eleven custom skills in active use on a real codebase.
• An authored plugin toolkit — looper, grind, worktree, patterns, retro, qa-gate, instructions-audit — that turns Claude into a batch worker: a queue of scoped jobs, each a fresh session, each committing as it goes and reporting back.

These are not prompts in a text file. They are versioned, governed, and treated as first-class engineering artifacts.

The core discipline is simple and strict: the plan is the contract. Intent is written down before code; progress is ticked only when a real run verifies it, never when the code merely looks right; and when reality diverges from the plan, the divergence is a bug to fix at the source — you do not quietly patch the doc to match the code, and you do not plow ahead against it.

The same discipline draws a hard line agents love to cross: a strict content boundary keeps NDA'd work out of anything public, and every session honors it without being reminded. Guardrails, in other words, are not a feature I bolt onto the LLM product at the end — they are how I run the agents that build it.

Building with LLMs and building LLM products reinforce each other. The HomeWise concierge is the clearest example: server-enforced output scope so the model cannot answer outside its property, defense-in-depth guardrails (nonce → rate limit → spend caps → allowlist), prompt caching tuned to a cost-derived breakpoint, and an answer cache that returns a repeat question in about 2 ms for zero tokens. That is cost engineering and safety engineering on an LLM, not a wrapper around one.

The Food Bills pipeline shows the workflow side — a raw → wiki → reports knowledge pipeline with a custom /add-bill agent skill and source-based confidence gating, so an LLM-authored knowledge base stays trustworthy.

The strongest evidence is the artifact you are on. This portfolio was built content-as-code by an agent loop — a queue of scoped jobs (scaffold, content model, theme shell, one job per interactive toy, one per case study, plus verify-and-fix gates), each a fresh Claude session running under the plan and committing its own work. The perf audit job caught a real mount error in one toy; the fix job resolved it and re-verified in a browser; a content-safety job re-read every case study to confirm zero employer leakage. That is the practice, running on itself.

The code is public: github.com/matijajanc.