The No AI Slop manifesto went live on November 13, 2026, published by speakers and attendees of AIE Code Summit 2026. It is not another model release. It is a team charter for the moment agent swarms can produce more text and code in a day than a human can review in a career.
The document opens by comparing itself to the 2001 Agile Manifesto, then states what modern teams should value: outcomes over output, understanding over speed, our own thinking over a model first draft, better work over easier work, and improving the system over patching the output.
TL;DR
| Question | Answer per the manifesto |
|---|---|
| What is slop? | Work where authors invest less effort than they demand from readers or reviewers |
| Does AI cause slop? | Not necessarily — slop appears when people pass model output through without ownership |
| Core risk | Asymmetric cost: generating a 1,000-line PR is cheap; reviewing it is not |
| Compounding | Slop in chat, docs, and repos becomes training context for the next agent pass |
| Fix pattern | System and guardrail changes after the second identical mistake |
Why another slop document?
explainx.ai already covered Peter Yang open-source skill that strips known AI prose tells. The summit manifesto attacks a wider failure mode: orgs that reward token throughput and parallel agents without updating review culture.
Beliefs on the page include:
- AI amplifies judgment, good or bad; it does not replace it.
- Pressure from leadership pushes unrealistic output targets.
- Slop compounds when the next agent reads yesterday unreviewed draft in the knowledge base.
- Teams stop fighting slop when noise becomes normal, and quality drifts down.
That matches what Hacker News readers argued in the No AI Slop thread: the problem is often incentives, not whether a model wrote a paragraph.
Identical gray blobs on a conveyor beside one green gem, illustrating AI slop versus reviewed agent output
Values and resolutions builders can adopt
Values (paraphrased from the primary text)
The manifesto contrasts speed with understanding, and model drafts with human intent. For platform teams, that translates to design docs before agent floods, not after.
Selected resolutions
The undersigned commit to ideas including:
- Optimize human attention — do not burn reviewer cycles on unlabeled agent dumps.
- Do thinking before generation — explore code and prior art; do not prompt cold on unknown repos.
- Disclose agent-authored sends and check parts that matter.
- Tell teammates kindly when they forwarded slop; most people needed that note once.
- Review a stakes-appropriate subset — linters help but are not sufficient for high-risk surfaces.
- Measure outcomes — who uses the feature and whether it helps — not lines merged or agent count.
For security-adjacent agent work, pair this charter with social-engineering and prompt-injection hygiene and with honest discussion in Is AI writing safe on the job?.
What developers are saying on Hacker News
The HN thread mixed sign-offs with pushback on whether a manifesto changes team incentives:
- courtcircuits tied the “improve the system” line to giant AI PRs, suggesting reviewers ask for the prompt so they can judge whether the submitter’s process was sound — a workflow idea, not a site policy.
- mschuster91 argued review cost can grow as teams shrink, and that a 1,000-line AI slop PR is far harder to parse than a careful human diff — their opinion on review economics.
- seizethecheese questioned whether the manifesto’s slop definition caps AI productivity, citing Terry Tao’s remark that mathematicians may now interpret AI-generated proofs — skepticism about the wording, not a lab result.
- ozgung called the closing “comments welcome” block engagement bait and said slop should be defined up front — harsh tone, but a fair critique of structure.
Those views belong to commenters. For longer-form comparisons, readers also pointed to the Proton engineering manifesto and multiplayer agent manifesto essays.
How this differs from skills, linters, and detectors
| Approach | What it fixes | What it misses |
|---|---|---|
Peter Yang /no-ai-slop skill | Prose patterns in drafts | Team incentives and PR size |
| Linters and type checkers | Known syntax and style classes | Whether the feature should exist |
| Substack Pangram-style detectors | Suspected AI prose in publishing | Maintainable system design |
| This manifesto | Cultural defaults and review obligations | Nothing technical by itself |
If you run Claude Code or Codex at high parallelism, the manifesto implied policy is: cap unreviewed merge volume, not cap models.
Practical checklist for a team lead
- Label agent-assisted PRs in description templates.
- Set review rules by risk — auth, billing, and exports get human eyes on full diffs; docs might get sampled review.
- Ban silent paste from chat into customer tickets without a read-through.
- After duplicate bugs, add automation (tests, types, policy scripts) instead of another reminder comment.
- Track incidents and user outcomes, not daily token spend alone.
Signing, governance, and how the list evolves
The manifesto invites signatures through a GitHub gist comment template: name, company, X handle, or LinkedIn. That is closer to community norm-setting than vendor certification. Early signers listed on the page include Dex Horthy, Kent C. Dodds, Tejas Kumar, and Lauren Tan, plus contributors thanked in the footer.
For engineering directors, the governance question is not "did we sign?" but "do our CI rules enforce what we signed?" Examples that align with the text:
- Required reviewer on files touching auth, payments, or exports, even if an agent opened the PR.
- Maximum diff size soft caps for agent-generated changes unless a human writes a short intent note.
- Docs lint that flags paste-heavy pages with no human edit timestamp.
- Incident retros that ask whether slop in an internal wiki misled the next agent task.
The manifesto linked essays — swyx's "No More Slop", Tejas Kumar on keeping slop out of writing, Jake Nations on vibe coding disaster, Ghostty maintainers on human understanding — form a reading trail for staff onboarding. None replace your own style guide, but they give language for kind pushback when a teammate forwards raw model output.
Slop in codebases versus slop in comms
The manifesto spends equal weight on code and messages. That matters for agent-heavy teams because models are additive by default: they suggest more files, more flags, more wrappers. The text explicitly blames tools that lean toward adding rather than subtracting, echoing complaints in Claude load-bearing Claudisms coverage about recognizable AI prose tells.
In code review, slop often looks like:
- Wide refactors touching unrelated modules "while we were here."
- Duplicate utilities because the agent did not search the monorepo.
- Comment blocks that restate obvious code and hide missing tests.
- Feature flags with no removal plan, increasing cognitive load for the next human.
In comms, slop looks like long Slack summaries nobody asked for, or customer replies with confident tone and wrong specifics. The manifesto's fix is social: tell the sender kindly, and disclose when agents drafted.
Measuring outcomes instead of agent throughput
The resolutions reject lines of code, PR count, token spend, and parallel agent fan-out as success metrics. That directly conflicts with some internal dashboards vendors sell. A healthier dashboard might track:
| Metric | Why it fits the manifesto |
|---|---|
| Defect escape rate after agent-assisted merges | Catches unreviewed risk |
| Time-to-understand for onboarding engineers | Proxies documentation slop |
| Customer rework tickets tied to AI drafts | Surfaces comms slop |
| Repeat incident count before automation added | Rewards system fixes |
Pair those metrics with skills-based workflows in what are agent skills so conventions live in versioned artifacts, not one-off chat prompts.
Policy alignment without becoming performative
Legal and compliance teams sometimes ask for "no AI" bans after a bad incident. The manifesto argues a narrower stance: AI is fine; unowned output is not. That distinction can unblock Claude Code or Codex pilots while still satisfying audit asks for human approval on external sends.
If your org already runs Amazon Bedrock per-user cost tracking, add a qualitative column in the same review: did the author read the diff? Tools cannot answer that; managers can sample reviews weekly.
A green magnifying lens inspects a replacement tile in a cream mosaic, illustrating careful review of agent-generated changes
FAQ-style questions teams ask after reading
Should we block agents until we sign? The manifesto does not ask for moratoriums. It asks for disclosure, review, and system fixes. Blocking often drives usage underground, which increases slop risk.
Does signing create legal liability? It is not a contract. Treat it like the Agile Manifesto: a shared vocabulary for retrospectives and hiring rubrics.
How does this interact with Substack or Pangram detectors? Detectors flag likelihood of AI prose. Slop is about reader time wasted regardless of authorship. A human can write slop; an agent can produce non-slop with editing.
What about open-source maintainers flooded by agent PRs? The compounding-slop clause applies doubly: bad agent patches become examples for the next contributor model. Maintainers should publish minimal contribution templates and close unlabeled agent dumps fast.
Related reading
- Peter Yang no-ai-slop skill — editable writing patterns for Claude
- Proton AI manifesto for engineers — engineering identity under agents
- Multiplayer AI manifesto — shared cloud agents for teams
- Lawyer full-time AI billing ethics thread — professional responsibility when output is cheap
- Dougan leak and AI news slop — when scale without verification poisons information diet
- What are agent skills — where team conventions can live as versioned skills
Manifesto text and signers reflect slopmanifesto.com as published November 13, 2026.