Agentic Garage
Agentic Engineering Experiments
How I actually build now — pairing with coding agents to go from task context to a reviewable pull request.
Problem
Engineering tasks carry a lot of repetitive weight: context gathering, ticket interpretation, boilerplate, and PR summarization.
Solution
Wiring agentic workflows into real work — reading tickets and codebases, generating focused changes, opening PRs, and summarizing them for review — while keeping the judgment human.
Role
Designing the workflows, context handoffs, and review boundaries I use to build platform tooling at AI speed.
Impact
- Turns task context into a reviewable pull request
- Keeps judgment and review with a human
- Removes repetitive context-gathering and boilerplate
- The working method behind Ohara, Franky, and Morgans
Visual metaphor
Robot garage with prompt terminal, code station, and PR machine.
Highlights
Context
A surprising amount of engineering time goes to work around the work: gathering context for a ticket, interpreting what’s actually being asked, writing boilerplate, and summarizing a change so a reviewer can understand it quickly. These steps are repetitive but not trivial — exactly the shape of problem worth testing AI-assisted workflows against.
This is an ongoing set of experiments, not a shipped product. The goal is to learn where agentic workflows genuinely help in a mobile platform context, and where the handoff to and from a human should sit.
Approach
The experiments explore an end-to-end loop rather than a single magic prompt:
- Context in. Pull task context from Jira, Figma, or free-text prompts so the agent starts from the same information a human engineer would.
- Work in the codebase. Let the agent read the repository, generate changes, and open a pull request.
- Context out. Summarize the work for review, so the human spends their time judging the change instead of reconstructing it.
The recurring design question underneath all three is where the review boundaries belong — what the agent decides versus what a person must sign off on.
How it works
A workflow takes a task description and its surrounding context, inspects the relevant code, produces a change, opens a PR, and writes a summary aimed at the reviewer. Around that loop sits measurement: tracking how the agent performs so the experiments produce evidence, not just anecdotes.
The framing — a robot garage with a prompt terminal, a code station, and a PR machine — captures the intent: a small assembly line for turning context into a reviewable change.
Outcome
So far the value shows up as faster prototyping, cleaner PR handoff, less repetitive context-gathering, and a more structured way to think about AI-assisted engineering. Because this is experimental, the honest result is direction and learning rather than a finished metric.
What I’d explore next
The open threads are sharper measurement of agent output quality, clearer rules for when a human must intervene, and tightening the context handoff so the agent starts with less ambiguity and produces changes that need fewer review rounds.