Thoughts about agent runtimes, developer tools, product decisions, and the latest in agentic engineering.
Before goldengoose had a team-status card, the lead drew one in Markdown. Turning that repeated report into deterministic UI gave the model and me one runtime-owned view of the team.
My lead can absorb feature requests all day because every agent works in a clean worktree and hands back an exact commit range. The underrated command is cherry-pick: it lets the lead replay approved histories onto a disposable candidate, test the combination, and keep main out of the mess.
Compute became payroll, but the salaries are flat: subscriptions decoupled dollars from usage so thoroughly that money stopped being the operative currency. What's left to budget is tokens, turns, and wall-clock time, and knowing where to overspend each one is most of running an agent team well.
My agents have names, roles, DMs, onboarding, and a rule about going home before they get sloppy. Treating them like colleagues isn't sentimentality; it's the cheapest, most reliable interface into both the model's training and my own management instincts. The skill is knowing where the metaphor pays rent and where it lies.
Two context-engineering features I built into goldengoose: compaction notifications routed to whoever created the agent and a context gauge any teammate can read. Then there is the planning habit that makes them rarely necessary: scope phases like context is the currency, and bias under-scoped.
I never tell my agents what to name files, how to shape arguments, or where anything should live. That's deliberate: a model's first impulse is a probability distribution over millions of codebases, and every arbitrary house convention you impose fights it twice, forever, on every agent that touches the repo.
The one agent I talk to all day never writes code. It delegates, schedules, integrates, and makes the judgment calls no benchmark measures. After living with this workflow daily, I think Claude models are post-trained into something specifically suited for that role.
The most useful thing I ever learned about prompting wasn't a prompting technique: it was understanding how frontier models are post-trained with reinforcement learning. Models are raised chasing verifiable objectives, which means any knowledge-work task becomes tractable if you can put a verifier in front of the goal.
I built MCP tooling two weeks after the protocol was announced, and today almost every tool I hand my agents is a CLI instead. This isn't the usual polarized take: CLIs win on tokens, priors, and self-documentation, but MCP keeps one property nothing else has: state.
Every artifact in my engineering process ends up as a markdown file, which makes the most important surface in my workflow a markdown viewer. goldengoose's has no editor, on purpose: as agents got better at instruction following, writing markdown stopped mattering. Reading it is the whole game.
I didn't plan to build a process manager. But the two providers under goldengoose disagreed about everything terminal-shaped, neither gave me programmatic control or observability, and both wasted agent turns on polling. Owning that layer changed how I ship daily.
I bounced off git worktrees twice before they became essential to how I ship daily. What changed wasn't the worktrees. It was realizing that isolation is the cheap half of parallel work, and everything I was missing lived in the expensive half: integration.
The most useful thing I've learned about working with coding agents isn't a harness or a workflow. It's that no amount of intelligence or compute applied to a thin specification beats a long conversation with the model before anything gets planned or built.
Most of my tools went from annoyance to published binary in a day. That cadence is the whole point, and Go is the language that protects it: near-instant builds, a compiler strict enough to let agents build in parallel without drift, and a fast native binary at the end without any performance engineering.
Rust's strictness has always been a trade: correctness for writing speed. Agents make writing nearly free, which turns the trade into a subsidy and makes Rust the best language I know for letting agents build the services that hold your state.
goldengoose has a native Rust runtime underneath it, and everyone assumes that's where the hard engineering lives. It isn't. The frontend, rendering twenty concurrently streaming agents without guessing, freezing, or lying, took more out of me than the runtime ever did.
My RPI pipeline ends with a reviewer clearing the diff, but a diff can't tell you the modal opens behind the header. So for web apps I added a stage after review: an agent that opens a browser, uses the feature like a person, and files what it finds back to the implementers.
Every non-trivial feature I ship goes through a research → plan → implement pipeline run entirely by agents. The whole process is five markdown files in .agents/skills, and the weird rules in them are the interesting part.
I climbed every rung of the LLM abstraction ladder, from raw API wrappers through my own unified interface to the Vercel AI SDK, and every rung was the same completion API underneath. Then the providers open-sourced their harnesses, and the right foundation for agent products finally existed.
How I turned a ChatGPT subscription into a set-and-forget coding agent on a real Linux machine, and how it hands work back and forth with the agents on my laptop.