← Back to Blog

I taught my agent to develop like the shops I actually admire

  • ai
  • development
  • launch

My agent writes code like nobody in particular. It has read everything and absorbed the median of it — median structure, median caution, median taste. Meanwhile, the shops I actually admire have engineering cultures with edges: opinions about when to plan and when to ship, what a review is for, what gets written down. You can read their blog posts. Your agent won't act on them — not natively, not consistently, not unless someone turns the culture into an artifact it executes.

So that's what I built: dev-like turns a company's public engineering exhaust into an installable skill for your coding agent. /dev-like <shop> installs a cited workflow profile your agent can use while planning, reviewing, and shipping.

A company that ships in public leaves engineering exhaust behind — linter configs, CI workflows, CONTRIBUTING files, PR templates, conference talks, and lately the most concentrated form of the stuff: shipped agent configs. When Every published their compound-engineering-plugin (23,570 stars as of July 28, 2026), they weren't writing about their culture. They were shipping it, executable, as the artifacts their own agents run on.

A blog post tells you what a team believes; a .rubocop.yml tells you what they enforce. Revealed preference beats stated preference, and the revealed preferences are increasingly shipped in exactly the format an agent can run.

Steal the workflow, not the code

dev-like profiles a company's (or a developer's) engineering culture from public sources only and distills it into an installable Agent Skill: a develop-like-oxide skill carries the target's workflow shape, stack rationale, and review posture — with a provenance link on every claim.

The mechanics, briefly:

  1. Resolve. The target is matched against a registry of cached profiles (aliases work: theo.gg, t3, and Theo all land on theo).
  2. Cache hit. The distilled profile.md becomes a skill in your project — .agents/skills/, the shared path documented in the harness-support matrix, symlinked into .claude/skills/ for Claude Code.
  3. Cache miss. The agent runs a live collection workflow across a ranked source taxonomy, builds a cited profile, generates the skill — and offers to PR the profile back. Opt-in, never automatic; but it means a miss can end as the registry's next entry instead of a dead end.

The source taxonomy is ranked by signal, and the ranking is the whole thesis: shipped agent configs and repo configs at the top, first-party blogs and talks in the middle, social exhaust at the bottom, where it serves mainly as a falsification source.

What the Oxide profile actually contains

Oxide is the useful case because the culture is unusually legible from outside: its public RFDs record options, reasoning, data, and determinations, and its published workflow names the phases from scoping through production [RFD 1 and RFD 5]. The distilled skill carries that decision-doc-first shape, its rigor-with-urgency constraint [RFD 113], and the Rust/tooling practices documented in the profile.

Here's a deliberately small test: one Rust file with a ProfileService that calls a slow upstream API, and the same caching task run twice in Claude Code — before and after npx dev-like oxide (full transcript). Without the skill, the model released its read lock, called upstream on a miss, and wrote the result. It called two concurrent misses "harmless." With the skill, the model added a second cache check after taking the write lock:

Double-check on the write path — between dropping the read guard and acquiring the write guard, another thread can win the race and populate the entry. Without the re-check, two threads arriving concurrently on a cold entry both make the upstream call. The extra cache.get() on the write path is cheap; the upstream call is 200ms+.

That is the finding I care about: the after-run version closed a real race in the cache write path that the baseline had waved off as harmless. The July 16 demo calls this the one unambiguous delta — more rigor applied to the same correctness question both runs identified.

That run also exposed the limit: it never wrote the decision down first. I changed the generated Oxide workflow to require a lightweight RFD-*.md record before code for meaningful design choices, then reran the eval on July 20. In two of two runs, the agent created RFD-profile-cache.md before service.rs, covering the problem, options, chosen tradeoffs, and failure modes. The follow-up eval records both artifacts and their timestamps.

Each claim in that profile links to the public source it came from. Uncited claims do not ship. The result is reviewable markdown in a PR.

The ethics section, because it's load-bearing

A profile you can't trust is worthless, so the trust rules are the product, enforced by the validator — not a disclaimer bolted on after:

One tension worth naming: a develop-like-theo profile exists in the registry, while third-party coverage associates Theo with the view that accumulated prompt configuration is technical debt. The profile labels that attribution as directional, not a located first-party quote. It keeps the contradiction visible rather than sanding it off — profiles that hide their subject's disagreements wouldn't be worth trusting on anything else.

What this doesn't do

Profiles are dated snapshots. Oxide's profile is dated 2026-07-11, so staleness is managed, not solved.

High-fidelity mimicry also isn't the goal, because it may be worse than useless: the profiles capture principles and workflow shape, not prompt-pile trivia. Installing develop-like-oxide does not make your team Oxide. It makes your agent stop developing like nobody.

The artifact-first result is bounded too: n=2, cue-assisted, one model, and one task family. File timestamps corroborate that the RFD preceded code; they are not direct tool-call instrumentation. The eval demonstrates the intended behavior in this sample. It does not prove that one skill reproduces an engineering culture across tasks or models.

Try it

Fastest first win — install the current Oxide skill, then give your agent a meaningful design choice and ask it to write the decision down before code:

npx -y dev-like@0.4.1 oxide

The receipts are public: the July 16 race review and the July 20 artifact-first follow-up. Then npx skills add marcusrbrown/dev-like to install the profiler itself in a supported harness, and /dev-like <shop-you-admire>. Cache misses get profiled live, and the agent offers to PR the result back — making the next profile reviewable, cited, and installable by the next person.

View on GitHub