Do Epic Shit Chat Mode (Beast Mode for GitHub Copilot)

Turning GitHub Copilot Chat Into “Beast Mode”

In my previous article on custom chat modes I showed how specialized modes focus Copilot. Today we go one step further: designing a so‑called “Beast Mode”, a maximal autonomy configuration for deep, multi‑step problem solving.

What Is “Beast Mode” Conceptually?

“Beast Mode” (not an official VS Code name) is a pattern for an aggressively proactive Copilot Chat configuration that:

1. Grants broad tool surface (codebase, search, usages, tests, tasks, terminals, fetch, repo introspection).
2. Enforces a strict iterative TODO loop before yielding control.
3. Requires fresh validation / research instead of relying on model memory.
4. Encourages recursive expansion (follow links, fetch more docs) until coverage is high.
5. Mandates post‑action verification: run tests, lint, or inspect artifacts.

It is best for non‑trivial refactors, exploratory debugging, orchestration across multiple subsystems, or generating first drafts of multi‑file features.

Why Was “Beast Mode” Created?

Community iterations (see also “Beast Mode v3 is here”) emerged to solve recurring pain points. Another goal: bring Copilot’s default (currently GPT‑4.1) closer to the “persistent reasoning depth” people appreciate in Claude Sonnet without burning premium requests and additionally to mitigate:

1. Premature agent exit – Default flows stop after surface answers; strict checklists enforce completion.
2. Shallow research – Prompts sometimes lean on stale internal knowledge; recursive fetch rules force live validation.
3. Hidden partial edits – Multi‑file changes risk inconsistencies; mandated verification (tests / lint) reduces drift.
4. Unstructured planning – Ad hoc steps reduce traceability; a canonical markdown checklist becomes an auditable log.
5. Tool over/under-use – Either terminal spam or neglect; curated tool lists create balanced, intentional capability.
6. Untracked evolution – Version tagging (v1, v2, v3…) allows empirical comparison of behavior changes.

These drivers shaped the norms later embodied—and extended—in more disciplined variants.

The Do Epic Shit Mode

This pattern inspired my colleague @kasuken and me to create our own version: the Do Epic Shit Mode—a hardened, opinionated realization of the Beast Mode idea.

The Do Epic Shit Mode File (Highlights)

Key traits from epicshit.chatmode.md:

• Frontmatter description: versioned (“4.1 Do Epic Shit Mode v1.4”) signalling iterative hardening.
• Wide tool array: changes, codebase, editFiles, runTasks, runTests, terminalLastCommand, searchResults, vscodeAPI, github—> maximizes observable + actionable surface.
• Model pinned: GPT-4.1 (explicit stability / capability expectation).
• Checklist format contract: exact markdown pattern required, forbidding HTML → predictable parsing for future automation.
• Explicit autonomy rule: “do not end your turn until everything is truly complete” → prevents premature handoff.
• Embedded operational doctrine: deep research, recursive exploration, reflection between steps, exhaustive verification.

Beast Mode vs Do Epic Shit Mode

The Do Epic Shit Mode operationalizes the abstract pattern into a repeatable, enforceable contract—the differentiator.

Why This Matters

Without a structured autonomy contract, large edits risk:

• Early termination leaving hidden TODOs
• Unverified assumptions about external APIs
• Shallow research (first‑page bias)
• Undocumented decision paths

The mode bakes safeguards directly into the interaction layer.

New VS Code Chat Settings & How They Differ

Recent settings surfaced in your editor configuration (see the official Copilot Chat docs, Copilot configuration overview, plus VS Code release notes):

"chat.todoListTool.enabled": true,
"github.copilot.chat.alternateGptPrompt.enabled": true

How they relate:

Difference vs in‑file checklist instruction: The mode hard‑codes the REQUIRED checklist format; VS Code’s TODO feature is optional infrastructure. If the checklist deviates, the mode becomes invalid regardless of tool assistance.

Designing Your Own High‑Discipline Mode

When forking or extending:

1. Keep the format spec minimal & strict (single source of parsing truth).
2. Explicitly list every tool—avoid implicit defaults so changes are intentional.
3. Add a short version note in description for auditability.
4. Require reflection after each step (prevents autopilot drift).
5. Gate exit on: checklist empty + tests pass (if test suite exists) + lint clean.

Minimal Template Example

---
description: "Beast Mode v0.1"
tools: ["codebase", "search", "runTests", "runTasks", "terminal", "editFiles"]
model: GPT-4.1
---

You are an autonomous engineering agent. Follow the checklist until all items are completed & verified.

Checklist format:

- [ ] Step 1: ...
- [ ] Step 2: ...

Conclusion

The Do Epic Shit Chat Mode turns an aspirational “Beast Mode” notion into a codified operational framework: wide tool access, rigid checklist grammar, recursive research, and verification discipline. With new VS Code chat settings assisting (native TODO parsing + alternate base prompt), the mode itself remains the authoritative governance layer.

Key takeaways:

• Codify autonomy; don’t rely on model goodwill.
• Enforce deterministic checklist grammar.
• Treat research as a loop, not a single fetch.
• Version your mode—make evolution observable.
• Verification gates prevent “looks done” drift.

Next, you might explore deeper prompt tuning for quality improvements—see Improve GitHub Copilot Results for complementary techniques.

Have you built your own high‑discipline mode? Share ideas—I may feature interesting evolutions in a future post.