# Yuzzyuk/marketing-os: one markdown skill, fourteen scored modules, and an install path per client

> Marketing OS packages fourteen marketing modules into a single Claude skill that scores audits 0-100, grades copy variants before you read them, and states what it could not determine. It ships as pure markdown, so the trust question is a reading question and every action stays manual.

**Yuzzyuk/marketing-os** — An entire marketing department as one Claude skill. 14 modules: audits scored 0-100, an 18-tactic hook engine, copy graded before you see it, ad diagnosis, GEO, email, launches, pricing. Works in Claude, Codex and Cursor.

- Repository: https://github.com/Yuzzyuk/marketing-os
- Stars: 534 · Forks: 103
- Language: Unknown
- License: MIT
- Published: 2026-09-17 · Updated: 2026-09-17 · Language: en
- Canonical page: https://hysenlabs.com/projects/yuzzyuk-marketing-os

## Three install paths, and only one is a copy and paste line

Claude Code gets a two line install, and it goes through the plugin marketplace rather than a package manager:

```bash
/plugin marketplace add Yuzzyuk/marketing-os
/plugin install marketing-os@marketing-os
```

The web and desktop clients take a different route: Settings, then Skills, then the plus control, then upload marketing-os.zip pulled from the latest release. That path has a precondition the plugin route does not, since code execution has to be enabled on the client first.

Everything else, Codex and Cursor among them, is a file copy. Copy skills/marketing-os/ into your agent's skills directory, for instance ~/.claude/skills/marketing-os/. No lockfile, no dependency tree and no post install step, because there is nothing in the repository that executes.

Three routes means three failure modes: a marketplace name that has to resolve, a zip you have to fetch plus a client setting you have to flip, and a directory layout you have to match by hand.

## brand-context.md is the file every module reads

The setup step the README puts first is a single file. Copy brand-context.template.md to brand-context.md, fill it in, and drop it in your project root or in .claude/. Every module reads it, which is what keeps fourteen modules from producing the same interchangeable output three times over.

The stated cost of skipping it is precise rather than dramatic. The output is still competent, still well formed and still scored, it just describes a company nobody named, which the project calls the one thing marketing cannot be. That failure is harder to notice than a crash, since nothing errors out and the shape of the report looks right.

The template ships inside the skill directory, so the copy step behaves the same in Claude Code, in the desktop client and in a manual install. There is no separate configuration file format to learn and no environment variable to set before the modules mean anything.

## Progressive disclosure: a router near 2k tokens, thirteen dormant modules

The loading strategy is the reason a pure markdown package can carry fourteen modules. The router loads first at roughly 2k tokens, and each task then loads only the module it needs, so the unused modules cost nothing until something asks for them.

That changes which number is worth measuring. Total token count is the wrong one, since only the router plus a single module is ever resident. The number that matters is the router, because it decides which module loads, and a wrong decision there is invisible from the outside: you get a competent answer from the wrong module rather than an error.

Subagent-native fan out is the second half of the design. Audits, teardowns and variant generation are named as the multi-dimensional work, and those fan out in parallel when the host supports it. Hosts without subagents get the same modules, just serially, and the README attaches no feature flag to that difference.

## Every score is labeled as the heuristic it is

The scoring layer is where this skill separates itself from the genre it was assembled from. The audit module returns a weighted 0 to 100 with prioritized fixes rather than a list of observations. The copy module generates 15 to 20 variants, scores them through an expert-panel step, then runs a de-slop pass over the survivors.

Underneath sits what the README calls the honesty spine, and it is phrased as a set of refusals: no invented proof, no fake precision, no winners declared on ten conversions, and every score labeled as the heuristic it is. The rubrics and specs layer holds the scoring bands, the engine playbooks and the store field rules that make those labels concrete, while the slop-patterns module runs the AI-tell catalogue on all prose.

The third thing the project adds over the repositories it was built from is an explicit note of what could not be determined in every report. That is the part that keeps a 0 to 100 number from reading as a measurement.

## The hook engine runs 18 tactics into a matrix, then a funnel

The hooks module is the widest single engine in the package: an 18-tactic hook engine feeds a hook matrix, and the matrix feeds a diagnostic funnel. Three stages mean a failure can sit in any one of them, and the funnel is the stage that separates a tactic chosen badly from a tactic placed in the wrong slot.

The other engines are single-stage by comparison and read as deliberately narrow. Paid ads does concept-level fatigue diagnosis and hands back a ranked production brief. Competitive does teardowns from public sources. App-store does ASO diagnosis, metadata and screenshot sequences. Analytics is described as honest data reads and proper test design, which is the same no-fake-precision rule applied to measurement instead of to copy.

Positioning, email, social and launch fill out the rest, with the launch playbook covering Product Hunt and the email module writing welcome, nurture and launch sequences in full rather than outlining them.

## No executable code, so the trust question is a reading question

The repository states it plainly: no executable code, pure markdown, nothing to review before trusting it. The primary language field is empty for the same reason. What is there is seven top-level entries, a plugin manifest directory at .claude-plugin/, AGENTS.md, CONTRIBUTING.md, the MIT LICENSE, the README and the skills/ directory.

That shape has a consequence worth naming on both sides. A skill that ships only prose cannot run a build step, cannot drift against a dependency and cannot fetch anything at install time, so the supply chain question is about the text itself. The flip side is equally concrete: none of the fourteen modules can take an action in your environment, so every step from diagnosis to publication stays manual.

MIT licensing and a prose-only payload are also why the manual install is a directory copy rather than a command, and why the three client paths differ only in how the directory arrives.

## Ads reach produced assets only when an MCP is connected

The paid ads module stops one step short of a finished ad on its own. It does concept-level fatigue diagnosis and returns a ranked production brief, and that is where it ends without help.

With an ad-generation MCP connected, Arcads named as the example, the same flow continues into generation, so the chain reads diagnose, brief, produce inside a single session. The dependency sits on the MCP side rather than inside this repository, which is one reason the skills directory stays markdown only even in that configuration.

This is the one place where the package reaches outside itself, and it is worth knowing where the seam sits. The brief is produced by Marketing OS, the assets are produced by whatever MCP you connected, and the two carry separate licenses and separate failure modes.

## One release, v1.1.0, published the day of the last commit

The maintenance picture is simple enough to state in full. The repository is not archived, the default branch is main, and the last push is dated 17 August 2026. There is exactly one release in the list, v1.1.0, tagged Marketing OS v1.1.0, published at the same moment as that push.

So there is no gap between the release and the current tip, which is the reverse of the usual pattern where commits outrun tags. It also means there is nothing to compare against: no 1.0 to diff and no cross-version changelog telling you what a given change was meant to fix.

The numbers around it are 533 stars and 104 forks with 0 open issues. A fork count under a fifth of the star count, and an empty issue queue, tell you the distribution is wider than the visible conversation. Contribution rules are not set out in the README, but CONTRIBUTING.md and AGENTS.md are both in the tree.

## Conclusion

Marketing OS fits a marketer who wants scored, artifact-producing output from one markdown skill and who will spend five minutes writing brand-context.md before the first run. It does not fit anyone who needs it to publish, send or buy anything on its own, since nothing in the repository executes and the ad asset path depends on a separate MCP. Check three things before relying on it: that the 0 to 100 audit score and the 18 tactic hook engine are heuristics you will label as such in your own reporting, that a router near 2k tokens is what your host can afford to load on every task, and that the single v1.1.0 release gives you no earlier version to diff against.

## FAQ

### What is Marketing OS and how many modules does it contain?

It is a single Claude skill built as one marketing department, with fourteen modules covering website and funnel audits scored 0 to 100, an 18 tactic hook engine, copy grading, ad diagnosis, AI-search citability, email, launches, positioning, competitive teardowns, app-store optimization and analytics.

### How do I install Marketing OS in Claude Code?

Two slash commands, one adding the marketplace and one installing from it. The web and desktop clients instead upload marketing-os.zip from the latest release with code execution enabled, and Codex, Cursor and other agents get there by copying skills/marketing-os/ into the agent's skills directory.

### What should I set up before running Marketing OS for the first time?

Copy brand-context.template.md to brand-context.md, fill it in and place it in your project root or .claude/. Every module reads that file, and the README is direct that without it the output comes back competent and interchangeable.

### Does Marketing OS score what it produces?

Yes, and it labels the scoring as a heuristic. Audits come back as a weighted 0 to 100 with prioritized fixes, copy generates 15 to 20 variants that go through an expert-panel score and a de-slop pass, and the design principles rule out invented proof, fake precision and winners declared on ten conversions.

### Can Marketing OS generate the ad assets it writes a brief for?

Only when you connect an ad-generation MCP such as Arcads. Without one, paid ads stops at concept-level fatigue diagnosis and a ranked production brief. With one connected, the flow runs diagnose, brief, produce in a single session.

## Sources

- [Issues](https://github.com/Yuzzyuk/marketing-os/issues)
- [License: MIT](https://github.com/Yuzzyuk/marketing-os/blob/main/LICENSE)
- [README](https://github.com/Yuzzyuk/marketing-os/blob/main/README.md)
- [Releases](https://github.com/Yuzzyuk/marketing-os/releases)
- [Yuzzyuk/marketing-os on GitHub](https://github.com/Yuzzyuk/marketing-os)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/yuzzyuk-marketing-os