Skip to content

Agentic engineering, done right

Code is now disposable.Specifications are the product.

I help engineering teams adopt agentic engineering the right way, with the rigor that makes machine-generated code safe to ship. The opposite of vibe coding.

Reject expired invite links

Issue 412, in progress

5 of 6
  1. SpecAcceptance criteria written, 4 of 4 testable
  2. TriagePlan agreed, two files in scope
  3. DeveloperChange made in a sandbox, tests pass
  4. ReviewerOne change requested, resolved
  5. TestsNo new failures against the base branch
  6. QABooting the app, checking criterion 3 in the browser
  7. YouApprove the merge

What I do

Four ways I help engineering teams ship better.

Agentic Engineering Adoption

I coach engineering teams through the shift from writing code to specifying intent. Claude Code & Cursor rollouts, spec-first workflows, and supervisory protocols — so your seniors stop drowning in machine-generated code.

Custom Agent Infrastructure

Autonomous pipelines built on embry0, my open-source engine, and wired into your dev workflow. An issue becomes a reviewed pull request: triage, developer, reviewer and QA agents in sandboxed containers, with a person approving what matters.

See embry0

Specification & Test Rigor

I turn fuzzy PRDs into AI-ready specs: state machines, decision tables, hallucination-proof test suites. The same standards safety-critical avionics teams apply to flight hardware — applied to AI-generated code.

Senior Engineering Work

Hands-on architecture and development. When you need a senior who can ship the thing, not just talk about how to ship it. Backend systems, agent infrastructure, secure networking, full-stack.

Open source, MIT licensed

embry0 turns an issue into a reviewed pull request.

A self-hosted engine I built and now publish in the open. A triage agent plans the job, a developer agent writes the change, a reviewer sends it back until it is right, and a QA agent boots your app to check it in a real browser. You run it from a dashboard that can look like a pixel-art guild or a plain operations console.

embry0, the guild hall

The guild hall. Every agent has a desk. You see who is busy, what is on offer and what is waiting for your review.

How a job moves through it

An issue

  • GitHub or GitLab
  • Linear
  • or work it finds itself

Orchestrator

  • LangGraph workflows
  • Postgres checkpoints
  • agents never run here

Sandbox, created for this job and destroyed after it

non-root, capabilities dropped

  1. Triagereads the issue, plans the job
  2. Developerwrites the change, opens the PR
  3. Reviewersends it back until it is right
  4. QAboots the app in its own sandbox, checks it in a browser

Developer and reviewer loop until the reviewer approves. Your tests then run on the old code and the new, and only new failures stop the job. QA runs when the change touches an app it can boot.

Credential proxies

  • hold the forge tokens
  • the sandbox never sees them

A reviewed pull request

  • QA verdict on the ticket
  • waiting for your merge

You, at any step. Agents stop and ask when they are unsure. Answer from the dashboard, Telegram or a GitHub comment.

Any model, per agent. Claude, Grok, OpenAI-compatible providers, or a local model on your own hardware.

embry0 architecture: an issue from GitHub, GitLab or Linear, or work embry0 found itself, reaches the orchestrator, which starts a sandbox for the job. Triage, developer and reviewer agents work inside it, the repository's tests run on the old and new code, and QA boots the app in a sandbox of its own. Pushes go through credential proxies that hold the forge tokens, and the result is a reviewed pull request. A person can answer questions at any step.
Each job in its own sandbox
Agents run as a non-root user in a throwaway container with every Linux capability dropped. Sandboxes cannot reach each other or your private network.
Forge tokens stay outside
Git, GitHub and GitLab credentials live in proxies beside the sandbox. The agent can push its branch; it never holds the token.
Checked in a real browser
The QA agent boots your app and drives it with Playwright, then keeps screenshots, console output and logs as evidence in the dashboard.
Your choice of model
Claude, Grok, any OpenAI-compatible provider, or a local model behind vLLM, Ollama or LM Studio, chosen per agent.
A person stays in charge
Agents ask when they are unsure. Answer from the dashboard, Telegram or a GitHub comment, and approve merges from chat.
Budgets and access control
Budget caps per job, per day and per month; a job that reaches its cap pauses and asks. Single sign-on, scoped API keys and an audit log.
LangGraphClaude Agent SDKFastAPIReact 19PostgreSQLDockerPlaywrightMCP

Results

Measured before it touched a price.

A freight brokerage. I designed and led its AI backend, and built the pricing models, the email pipeline and the deploy platform.

  • 12.5% → 8.1%

    Typical error when predicting what a dry-van load will cost to cover, against the industry rate benchmark.

    Backtest on 8,414 loads over 90 days. The window used to choose the design was kept separate from the one used to score it.

  • 23.8% → 9.0%

    Typical error on power-only loads, against the per-mile rule.

    1,317 loads over a year, with the model refitted every month and scored only on loads it had not seen.

  • 3× faster

    Email classification after constraining the model to a structured reply: 756 ms instead of 2,254 ms, agreeing with the stored labels 96.6% of the time.

    Holdouts of up to 5,000 threads. It caught 98.2% of new quote requests.

  • About 6 million

    Email classifications into nine business categories by an open-weight vision model on the company's own GPUs.

    No email left the building. Attachments are read as images, and text is redacted before it is used for training.

432 production releases in about six months, each one through a canary and a verify window with automatic rollback. The client is not named. Every figure comes from a written backtest or evaluation report.

How I think about this

Typing code is no longer the job.

AI hasn't made engineering easier. It has moved the bottleneck upstream. Code is disposable; specifications are the product. And the supervisor who doesn't understand what the system is doing is the one who crashes the plane.

Specification is the productAgent-sized chunksBlind AI is useless AI

Good fit

Who I work with.

If that sounds like you, we should talk.

  • Engineering teams of 5–30 at companies that ship software as a core part of the business.

  • Teams already using or seriously evaluating Claude Code, Cursor, or similar AI coding tools.

  • Senior engineers who feel like they're drowning in machine-generated code.

About

Behind Eastwood AI.

I spent my career in domains where software failure isn't an inconvenience: avionics communication platforms, embedded firmware for industrial control systems, and secure network infrastructure for high-assurance environments.

The through-line: every system I've shipped has been one where "kind of working" is unacceptable. Safety-critical hardware. Regulated environments. Networks carrying traffic nobody can afford to leak. AI-generated code in production needs the same standard.

Eastwood AI is how I help engineering teams hold that line while moving faster than ever — through coaching, custom agent infrastructure, or hands-on engineering work.

Let's talk.

Free 30-minute intro call. No pitch deck, no sales pressure. We figure out together whether we're a fit.