metaflora-dumb-dev

# Metaflora Dumb Dev > A mode for AI developers that prevents the model from building a cathedral where a stool is needed.  **Metaflora Dumb Dev** is a rough but useful mode for coding agents. It forces the agent to choose the shortest working path, avoid dragging unnecessary libraries, refrain from spawning abstractions "for the future," and not waste tokens on explanations that nobody asked for. The idea was born after looking at [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail): there, the agent is given lazy senior dev behavior, choosing YAGNI, standard library, and minimal implementation. **Metaflora Dumb Dev** takes this minimalist foundation and makes it more aggressive, meme-worthy, and token-economical. It's a separate product with modes like `vibe`, `chill`, `IDGAF`, brutal review, `dumb-score`, and `eat-these-tokens`.  ## What is this? This is not a framework or another "agent system." It's a behavior layer for AI coders. It's needed when the model starts generating architecture, providers, adapters, factories, configs, and long reports on why it's all "scalable" instead of making a small fix. The main idea is simple: if the code doesn't need to be written, it shouldn't be written. If there's already a necessary helper in the project, use it. If the language, browser, or Node can do the required thing, don't install a package. If a task can be solved with one function, don't create a directory with five files. Metaflora Dumb Dev doesn't promote sloppiness. It doesn't cut security, validation, auth, accessibility, and tests that genuinely protect behavior. It cuts code anxiety, "just in case," interfaces with one implementation, factories for one object, and multi-page responses after a three-line change. ## Why is this needed? AI agents often overcomplicate not because they're stupid but because they want to appear useful. It's easier for them to write more: more files, more layers, more explanations, and more "approach options." In the interface, this looks like work. In the repository, it turns into garbage that needs to be read, fixed, reviewed, and fed back to the model in context. Metaflora Dumb Dev does the opposite. It constantly asks: "what's really needed here?" If the answer is "add a filter," it shouldn't spawn a state manager, custom hook, provider, and separate config. It should find where the data already exists and write a filter. The most important thing: savings here aren't just in lines of code. Less code means less context in future tasks, fewer tokens for review, fewer tokens for debugging, and fewer chances that the next model will drown in the architecture the previous one invented out of boredom. ## Modes  In `vibe`, the agent simply writes more simply. Without lectures, without drama, without "let's consider trade-offs." It makes a short working variant and calmly reports that it didn't add extra overhead. This mode is for cases when you need a result, not a scolding. In `chill`, the agent starts talking like a senior who's slightly annoyed. It still helps but doesn't pretend that a factory for one class is normal engineering. A comment in this mode sounds like: "I think we're overcomplicating things: here’s one function, but the code is like a platform." `IDGAF` is a mode without diplomacy. If the task is unclear, the agent makes a minimal working variant and demands proof of the necessity of complexity. It can directly say: "I won't build a plugin system for one button. Here are 6 lines that solve the task. Want something more complex? Show me a second user of this abstraction." ## Seven features The first feature is the modes `vibe`, `chill`, and `IDGAF`. These aren't "quality" levels but tolerance levels for overengineering. `vibe` silently simplifies, `chill` explains where the nonsense began, and `IDGAF` doesn't let complexity pass without proof. The second feature is **senior comments**. A regular linter writes "consider simplifying this abstraction." Metaflora Dumb Dev writes in a human-friendly way: "what’s the point of this layer if it just calls another layer?" or "this isn't scalability, it's anxiety." These comments should be rough in form but accurate in substance. They don't attack the person; they attack useless complexity. The third feature is **dumb-score**. This is an assessment of how much the diff tried to look smarter than needed. If the agent removed unnecessary files, reused existing helpers, used `Intl` instead of a new dependency, and left a small runnable check, the score increases. If it added a library for one function, an interface with one implementation, a config that nobody changes, or five files for one `if`, the score decreases.  The fourth feature is **brutal review**. This review doesn't add more advice. It shows what can be removed. A good output doesn't look like corporate fluff but a short list of crimes against simplicity: replace a custom date picker with `input type="date"`, remove a factory for one class, hardcode a setting that nobody changes.  The fifth feature is **shortest path or play dumb**. The agent first checks if the task can be avoided, then looks for something ready in the project, then checks the standard library, then the browser or Node capabilities, then existing dependencies, and only then writes new code. If the user or another model chooses a complex path, the agent "plays dumb" and asks a simple question: "explain like I'm stupid, why do we need an event bus if there’s only one event?"  The sixth feature is **eat these tokens**. This mode literally "eats" useless text. All preludes, task retellings, obvious explanations, "there are several ways to approach this," and long summaries after a small diff turn into junk food and disappear. The output leaves only what's needed: what was done, what wasn’t done, why, and what was checked.  The seventh feature is **no future bullshit**. The agent doesn’t write code for imaginary requirements. If there’s currently one provider, no registry is needed. If there’s one format, no plugin interface is needed. If there’s one request, no repository factory is needed. Future requirements don’t pay for today’s complexity. When a second real use case appears, there’s a reason to complicate things. ## How dumb-score works `dumb-score` isn’t for beauty. It turns the feeling "the code has ballooned" into a clear signal. The starting score is 70 out of 100. The agent then awards points for removing garbage, reusing existing code, using standard libraries, native APIs, removing dependencies, and reducing tokens. Points are deducted for dependencies for one function, abstractions with one implementation, configs without users, TODOs without triggers, and re-reading half the project without reason. Example output: ```txt dumb-score: 38/100 - new dependency for one function: -25 - interface with one implementation: -20 - five files for one if: -18 + 140 lines removed: +20 + used Intl instead of package: +10 verdict: the code put on a suit to go get milk. ``` The "training" here is deliberately simple. It’s not magic or an ML promise. The agent must remember the project map: where the API client is, where date utils are, where validation is, and where UI components are. If there’s already a suitable helper in the project, reinventing the same helper gets a bigger penalty. ## How brutal review works Brutal review looks at the diff and searches for what can be removed without losing meaning. It shouldn’t write a long philosophical analysis. It should name the place, explain why it’s unnecessary, and suggest a shorter replacement. Example: ```txt what’s this nonsense: - datePicker.tsx: custom calendar. replace with input type="date". - UserFactory.ts: factory for one class. remove. - config.ts: setting that nobody changes. hardcode. - package.json: library for formatDate. replace with Intl. result: -4 files, -1 dependency, -312 lines, -900 repetitive tokens. ``` It’s essential: brutal review isn’t allowed to throw out real guardrails. If a check protects money, data, users, access, or correctness, it’s not garbage. Garbage is a layer that exists only because the model decided "to make it beautiful." ## Token Conservation The most obvious conservation is in short answers. Metaflora Dumb Dev should not start with “there are several ways” and should not rephrase the task for the user. If the change is small, the answer is also small: what was done, what was missed, why, and how it was verified. But the main conservation is deeper. Extra code becomes future context. Each unnecessary abstraction ends up in grep, diff, stack trace, review, explanations, and subsequent prompts. Once added, `FactoryManagerAdapter` continues to consume tokens every time the agent tries to understand the project. Therefore, removing 300 lines is not just minus 300 lines. It's less text for future reading, fewer options for future debugging, and fewer reasons for the model to start building architecture around garbage. Another important part is the project map. Instead of re-reading half the repository every time, the agent should keep a short map: where's the API client, where's validation, where are date utils, and where are UI components. If the task is about dates, it goes to date utils. If the task is about a button, it goes to UI components. It doesn't pretend to see the project for the first time. `eat-these-tokens` formalizes this idea as a mode. It shows which tokens were consumed and leaves only the useful remainder: ```txt eat these tokens: burger: 420 tokens consumed — explanation of the obvious fries: 180 tokens consumed — "there are several ways..." soda: 260 tokens consumed — rephrasing the task remaining: - done: replaced formatter with Intl.DateTimeFormat - missed: new dependency - verification: npm test passed ``` Ultimately, output tokens, context tokens, code tokens, review tokens, and debugging tokens are saved. Less chatter in the response is pleasant. Less extra code in the repository is much more important. ## Usage In Codex, the main entry point is `.codex-plugin/plugin.json`. The manifest connects skills from `skills/` and MCP config from `.mcp.json`. Hook files are also in the repository, but the current Codex plugin validation scheme does not accept the `hooks` field within `.codex-plugin/plugin.json`, so the Codex manifest is left validation-safe. Claude-style host can use `.claude-plugin/plugin.json`, which points to `hooks/metaflora-dumb-dev-hooks.json`. Main commands: ```txt /dumb-dev vibe /dumb-dev chill /dumb-dev IDGAF /dumb-review /dumb-audit /dumb-score /eat-these-tokens /no-future-bullshit ``` By default, it's more logical to enable `chill`: it's already quite honest but doesn't turn every review into a fight. `vibe` is suitable for calm work, `IDGAF` — when the agent has already tried to build a platform from a single function. If you want to set the mode via environment: ```bash export DUMB_DEV_DEFAULT_MODE=chill ``` You can also put the config here: ```txt ~/.config/metaflora-dumb-dev/config.json ``` Example: ```json { "defaultMode": "chill" } ``` ## MCP For hosts where it's not possible to constantly mix hooks, there's an MCP server. It's located in `metaflora-mcp/` and provides the same instructions as a prompt/tool. Launch: ```bash cd metaflora-mcp npm install node index.js ``` Example client config: ```json { "mcpServers": { "metaflora-dumb-dev": { "command": "node", "args": ["./metaflora-mcp/index.js"] } } } ``` The MCP surface is small: prompt `metaflora-dumb-dev` and tool `dumb_dev_instructions`. This is enough for another host to get the mode rules without copying the README. ## Repository Structure The repository is structured as a real plugin-style project. Manifests are in `.codex-plugin/` and `.claude-plugin/`. Canonical behavior is in `skills/`: main mode, review, score, token eating, and prohibition on future bullshit. Slash-command shims are in `commands/`. Activation, mode tracking, and status line are in `hooks/`. MCP server is in `metaflora-mcp/`. SVG sketch notes are in `assets/`, and tests are in `tests/` to ensure everything doesn't fall apart. Tests: ```bash npm test ``` Generating sketch notes: ```bash npm run assets ``` ## What Not to Cut Metaflora Dumb Dev is rough but not irresponsible. It should not simplify what protects real behavior. Input validation, auth, access rights, error handling, data loss prevention, accessibility, and tests on important logic remain. If a piece of code protects users, money, data, secrets, or correctness, it's not "extra complexity". The goal of the mode is not to make the code stupid in a bad sense. The goal is to remove smart talk that doesn't bring benefits. ## Formula **Metaflora Dumb Dev** is a mode that tells the agent: > write less, prove complexity, don't feed the model tokens, and stop pretending that a button is an enterprise platform.