'dev-like' packages a company's engineering judgment —not its code— as a citable skill for agents

By Zendoric · July 30, 2026.

A developer who goes by marcusrbrown has published dev-like on Hacker News, a tool that does something fairly specific: instead of teaching a coding agent to program "well" in the abstract, it makes it program like a specific company. The user invokes `/dev-like <goal>` naming an engineering team or company; the tool crawls public sources and builds a cited profile of its process, its stack and its tradeoffs. That profile is installed as a "skill", an extension that a coding agent can load and apply from then on.

The example offered on the project's own site is illustrative. Faced with a fictional plan —"raw SQL in the controller, no tests so we can move fast, Redis for caching"— a generic agent gives textbook advice. The same agent loaded with the profile of Every, the media and tools company known for writing publicly about how it builds software, responds by citing that outfit's documented criteria: if raw SQL in the controller makes it harder for the next engineer (or the next agent) to find the query, it is a flat no; if skipping tests contradicts Every's model for maintaining velocity when agents write the code, it is flagged as such; every verdict links to the public source that supports it. The GitHub repository preserves the verified transcript of that exchange.

Installation is offered two ways: as a plugin for Claude Code itself (`/plugin marketplace add marcusrbrown/dev-like`), Anthropic's extension manager for its terminal agent, or via `npx dev-like <slug>` for cached installations with no human intervention (headless). If the target has not been profiled yet, the tool runs what the project itself calls "live OSINT" —open-source intelligence— and generates the profile on the fly, saved in isolation under `.agents/skills/`. There is also a public registry of already-compiled profiles, a channel to request that a new company be profiled, and ethics and consent guidelines that explain what is scraped from public sources and how a company can ask to be left out.

In general, this fits a trend we have been following closely: as coding models become commoditized, the contest shifts to the substrate around the agent —which extensions, which memory, which conventions it loads— not just how smart the underlying model is. Agent skill and plugin marketplaces (Claude Code among them) are the terrain where that is being played out, and dev-like is a small but clear experiment in that logic: turning a team's tacit judgment —the kind normally passed on only by osmosis inside the office— into a portable, installable artifact with footnotes.

Our reading is that the explicit attribution mechanism is the most defensible part of the project, and also the most fragile. Every verdict cites its source, which avoids the problem we have flagged in other cases —opaque training on someone else's material, like the kind that led Anthropic to pay 1.5 billion dollars over how it obtained certain data, not over training itself—: here there is no ambiguity about where each recommendation comes from. But a profile built only from what a company publishes in its own channels is, by definition, the version that company wants to show of itself, not necessarily how it works behind closed doors. Mistaking technical marketing for actual practice is a risk the project cannot resolve on its own with the good faith declared in its consent guidelines.

That said, the signal should not be overstated: as this piece went out, the Hacker News post had one point and zero comments, that is, an indie project that has yet to find traction or serious public scrutiny. What matters is not that dev-like will change how people program, but what it anticipates: if engineering judgment —not just the code— can be packaged, cited and distributed as an installable module, the next frontier of AI-assisted productivity is not that the agent writes faster, but that it inherits, traceably, the good judgment accumulated by the best teams. That is exactly the kind of leverage —democratizing something that is scarce and expensive today, senior judgment— that underpins our underlying thesis about long-term abundance, even if the road there runs through modest tools, with names like this one, that today almost nobody has seen.