nowsprinting-cc-unity — Summary

claude-code-settings-for-unity is a Unity-specific Claude Code plugin that ships 8 skills and 1 subagent purpose-built for C#/Unity Test Framework workflows. Its distinctive architectural choice is a two-agent pipeline: the plan-feature skill orchestrates a Plan agent (class/method design) and then dispatches the test-designer subagent — which runs on opus — to produce test cases before any code is written. The test-designer returns a formal TESTABILITY: PASS/WARN/FAIL signal; a FAIL loops back to re-invoke the Plan agent, creating a closed feedback loop entirely within plan mode. Skills are organized as folder-and-SKILL.md packages with companion resources/ reference files covering Unity YAML editing, the Unity Test Framework, and JetBrains MCP integration. The repo also ships a production-hardened settings.json with an elaborate deny-list covering destructive git operations, network tools, secret paths, Unity Library caches, and JetBrains MCP build/execute tools. Now archived, with its agent skills migrated to the separate unity-coding-skills repository.

Differs from seeds: Closest to superpowers (skills-only, no commands) but adds a domain-specific test-design feedback loop that no seed implements — the test-designer agent's TESTABILITY gate makes test-first mandatory rather than optional, unlike superpowers' "Iron Law" prompt instruction.

nowsprinting-cc-unity — Overview

Origin

Created by Koji Hasegawa (nowsprinting), a Unity/C# developer. The repository was designed as a personal settings and skills package for Claude Code in Unity projects. It has since been archived; live agent skill development moved to https://github.com/nowsprinting/unity-coding-skills.

Philosophy

The project's driving idea is that Unity C# development has domain-specific failure modes — especially around testability of MonoBehaviour-based code, Unity's YAML asset format, and JetBrains Rider's MCP integration — that generic Claude Code defaults do not address. The solution is tight, opinionated skills that enforce test-first design as a structural constraint (TESTABILITY gate) rather than a prompt suggestion.

Key philosophies visible in the skill prompts:

• Plan mode is reserved for feature design; bugs are handled by fix-bug only outside plan mode.
• The test-designer agent owns test cases exclusively — the Plan agent is explicitly forbidden from producing tests.
• TBD items in requirements are silently skipped unless they block the overall design.
• Unity-specific restrictions: no rm, no git checkout, no curl, no direct MCP build/execute, restricted Library cache access.

Author Note (from README)

"When creating an implementation plan in plan mode, the plan-feature skill produces a lean, maintainable test design and a test-first workflow, enabling Claude Code to implement and verify autonomously."

Archived Note

"The Agent skills previously published in this repository will now be managed at https://github.com/nowsprinting/unity-coding-skills."

nowsprinting-cc-unity — Architecture

Distribution

Claude Code plugin (folder layout with skills/ and agents/ directories + settings.json). No npm package, no CLI binary.

Install

Clone or copy the repository contents into your project's Claude Code settings directory. The README instructs adding JetBrains MCP server to .mcp.json:

{
  "mcpServers": {
    "jetbrains": { "type": "http", "url": "http://localhost:64342/stream" }
  }
}

Directory Tree

.
├── README.md
├── LICENSE.txt
├── settings.json                          # Permissions allow/deny list
├── agents/
│   └── test-designer.md                  # Subagent: opus model, test design specialist
├── skills/
│   ├── code-writing-guide/
│   │   ├── SKILL.md
│   │   └── resources/                    # Unity-specific reference docs
│   ├── edit-scene/
│   │   ├── SKILL.md
│   │   └── resources/
│   ├── fix-bug/
│   │   └── SKILL.md
│   ├── plan-feature/
│   │   └── SKILL.md
│   ├── run-tests/
│   │   ├── SKILL.md
│   │   └── resources/
│   ├── test-designing-guide/
│   │   └── SKILL.md
│   ├── test-writing-guide/
│   │   ├── SKILL.md
│   │   └── resources/
│   └── unity-yaml-editing-guide/
│       ├── SKILL.md
│       └── resources/
└── hookify.confirm-install-packages.local.md  # hookify plugin config

Required Runtime

• Claude Code with JetBrains Rider (for run-tests and edit-scene skills)
• JetBrains MCP Server Extension for Unity plugin
• No Node or Python required for the skills themselves

Enabled Plugins (settings.json)

"enabledPlugins": {
  "csharp-lsp@claude-plugins-official": true,
  "hookify@claude-plugins-official": true
}

Target AI Tools

• Claude Code (primary)
• Skill format is Claude Code native (skills/*/SKILL.md)

nowsprinting-cc-unity — Components

Skills (8)

Agents (1)

Hooks (0)

No hooks registered. Permissions are managed via settings.json allow/deny lists rather than lifecycle hooks.

MCP Servers Referenced (not bundled)

Scripts (0)

No shell or Python scripts. All automation is within skill prompts.

Templates (0)

No standalone template files; reference docs live under skills/*/resources/.

Settings

settings.json — comprehensive allow/deny list covering:

• Allowed: git read-only operations, gh CLI, rg, find, Unity/JetBrains domain web fetches
• Denied: rm variants, curl, wget, destructive git ops, database CLIs, secret file paths, Unity Library cache writes, JetBrains build/execute MCP tools

nowsprinting-cc-unity — Uniqueness

Differs from Seeds

Closest to superpowers (skills-only behavioral framework, no commands). However, superpowers enforces TDD via Iron Law prompt instructions, while nowsprinting-cc-unity makes it structurally impossible to skip — the plan-feature skill dispatches a separate test-designer opus agent whose TESTABILITY verdict gates plan finalization. Unlike any seed, this repo ties a specific external IDE (JetBrains Rider) to Claude Code skills via MCP, creating a Unity-specific toolchain where test execution (run-tests) requires the JetBrains MCP server to be running. The settings.json deny-list is the most comprehensive in the corpus — denying git checkout, curl, wget, database CLIs, JetBrains build tools, and Unity Library cache writes — treating security surface reduction as part of the plugin's value, not an afterthought.

Positioning

A Unity C# developer who wants Claude Code to enforce test-first design structurally, not just suggestively. The two-agent pipeline (Plan → test-designer) is the key differentiator: the Plan agent designs classes, the test-designer agent designs tests, and they are explicitly forbidden from crossing roles. This separation of concerns mirrors the Single Responsibility Principle at the agent-orchestration layer.

Observable Failure Modes

1. JetBrains MCP unavailable: run-tests and edit-scene skills silently fail without the JetBrains MCP server running on localhost:64342.
2. Plan mode detection brittleness: The plan mode check (ExitPlanMode in deferred tools) relies on Claude Code internals — any version change that renames this tool would break both plan-feature and fix-bug.
3. Opus cost: Dispatching the test-designer agent on opus for every planning session is expensive; no fallback or token-budget control is documented.
4. Archived state: The repo is archived; skills may drift from the live unity-coding-skills repo without updates here.

Explicit Antipatterns

• Modifying files inside Bash during test design (read-only constraint)
• Plan agent producing test cases (role boundary violation)
• Running fix-bug in plan mode (mode mismatch)
• Including format specifications in test-designer prompts (overrides self-contained format contract)