# TACHES Claude Code Resources: Commands, Skills, and Agents for Real Workflows

> TACHES Claude Code Resources is an MIT-licensed TypeScript plugin collection providing 27 slash commands, 9 skills, and 3 subagents for Claude Code, built around the philosophy that every workflow a developer might want is achievable through structured commands and self-healing automation.

**glittercowboy/taches-cc-resources** — A collection of my favorite custom Claude Code resources to make life easier.

- Repository: https://github.com/glittercowboy/taches-cc-resources
- Website: https://youtube.com/tachesteaches
- Stars: 1,982 · Forks: 411
- Language: TypeScript
- License: MIT
- Published: 2026-09-15 · Updated: 2026-09-15 · Language: en
- Canonical page: https://hysenlabs.com/projects/glittercowboy-taches-cc-resources

## What TACHES Provides for Claude Code Users

TACHES Claude Code Resources is a plugin collection built by the TACHES creator. It gives Claude Code users a ready-made set of slash commands, skills, and subagents that cover common workflow patterns: capturing and resuming interrupted work, separating prompt planning from execution, applying mental frameworks to decisions, and running systematic debugging sessions.

The philosophy stated in the README is that every workflow that could be useful is achievable, and the collection is built from that starting point. This shows in the breadth of what is included: 27 commands, 9 skills, and 3 auditor subagents, covering everything from todo management to a skill that sets up Geoffrey Huntley's Ralph Wiggum autonomous coding loop.

The repository targets developers already using Claude Code who want to extend it without writing each extension from scratch. It is not a standalone tool and requires an active Claude Code installation to function.

## The Command Categories

The 27 slash commands fall into six categories. Meta-prompting separates analysis from execution: /create-prompt generates an optimised prompt with XML structure, and /run-prompt executes saved prompts inside a fresh sub-agent context. This two-step pattern prevents the main context from being consumed by prompt refinement.

Todo management captures tasks with full context mid-conversation without derailing current work. /add-to-todos saves a task with its surrounding state, and /check-todos resumes work with that context intact. Context handoff through /whats-next creates a structured handoff document that can be referenced with @whats-next.md to continue work in a fresh session.

The thinking models category is the largest single group: twelve commands including /consider:pareto for 80/20 analysis, /consider:first-principles, /consider:inversion (asking what guarantees failure), /consider:5-whys, /consider:second-order, /consider:occams-razor, /consider:swot, /consider:eisenhower-matrix, /consider:10-10-10, /consider:opportunity-cost, /consider:one-thing, and /consider:via-negativa. Each applies a specific mental framework to the current problem. The /debug command rounds out the set with a systematic debugging methodology based on evidence gathering and hypothesis testing.

## Installing via Plugin or Manual Copy

The recommended installation path uses the Claude Code plugin marketplace:

```bash
claude plugin marketplace add glittercowboy/taches-cc-resources
claude plugin install taches-cc-resources
```

After installation, starting a new Claude Code session makes the commands and skills available.

For manual installation without the plugin system:

```bash
git clone https://github.com/glittercowboy/taches-cc-resources.git
cd taches-cc-resources
cp -r commands/* ~/.claude/commands/
cp -r skills/* ~/.claude/skills/
```

Commands install globally to ~/.claude/commands/ and skills to ~/.claude/skills/. Project-specific data such as generated prompts and todo lists lives in the working directory of each project rather than in the global location. This means a todo list captured in one project does not appear in another project's context.

## The Skills: Generators and the Debug Loop

The nine skills automate more complex multi-step workflows. The creation skills generate new Claude Code extensions: /create-agent-skill builds a new skill by describing what is wanted, /create-meta-prompt generates staged workflow prompts with dependency detection, /create-slash-command builds a new command with proper structure, /create-subagent creates a specialised Claude instance for an isolated context, and /create-hook builds event-driven automation.

The create-plans skill is designed for solo developers working with Claude. The README describes the output as a PLAN.md file that is itself the prompt for execution, not documentation that gets transformed later. The workflow is: brief, roadmap, optional research, PLAN.md, execute, SUMMARY.md. The skill supports domain-aware planning by loading framework-specific expertise files from ~/.claude/skills/expertise/ when they exist.

The debug-like-expert skill applies systematic debugging with evidence gathering and hypothesis testing. A heal-skill command can fix existing skills based on execution issues they encountered, which creates a self-repair loop for skills that fail in practice. Setup-ralph installs the Ralph Wiggum autonomous coding loop developed by Geoffrey Huntley.

## The Auditor Subagents

Three subagents provide quality review for the resources themselves. The skill-auditor reviews skills for best practices compliance. The slash-command-auditor reviews commands for proper structure. The subagent-auditor reviews agent configurations for effectiveness.

These auditors are invoked by the /audit-skill, /audit-slash-command, and /audit-subagent commands respectively. The design reflects the repository's self-referential quality: the tools used to build skills, commands, and subagents also come with tools to review and fix them.

The create-plans skill explicitly mentions quality controls in the README: research includes verification checklists, blind spots review, and critical claims audits. This pattern of built-in review appears across several skills in the collection, though the depth of each auditor's checks is documented in the individual agent markdown files rather than in the README.

## Maintenance State and Licence

The repository is not archived. The last push to main was on 2026-04-01. There are no GitHub releases; the collection ships directly from the main branch. The MIT licence permits modification and redistribution without restriction, which means developers can fork the commands and skills to adapt them to their own workflows.

Because the collection ships as Claude Code plugin and skill files, compatibility with the current Claude Code plugin API depends on which version of Claude Code is installed. The skill and command file formats have evolved across Claude Code versions, and files written for an older API version may not load correctly in a newer installation. The README does not specify a minimum Claude Code version.

The collection's self-healing design through /heal-skill partially addresses this: if a skill stops working after a Claude Code update, the heal-skill command can attempt to fix it based on the execution error. Whether that covers API-level format changes is not documented in the README. Developers who modify the commands or skills for their own use should version them separately from the upstream repository to avoid losing local changes when pulling updates.

## Conclusion

TACHES is useful for Claude Code users who want a structured library of slash commands, thinking model frameworks, and workflow automation tools without building each one themselves. The collection is particularly relevant for solo developers who want meta-prompting, systematic debugging, and context handoff across sessions. The last push to the repository was on 2026-04-01, so the collection reflects the Claude Code plugin and skill API as it existed at that date. Verify that the plugin marketplace command and skill file format still match the version of Claude Code you are running before installing.

## FAQ

### How do I use the TACHES thinking model commands?

The thinking model commands such as /consider:pareto, /consider:first-principles, and /consider:inversion are slash commands installed to ~/.claude/commands/. After installation, typing the command in a Claude Code session applies the named mental framework to the current problem or decision described in context.

### Can I create my own skills with TACHES tools?

Yes. The create-agent-skill skill builds a new skill by accepting a description of what you want, and /create-slash-command builds new commands. The /audit-skill and /heal-skill commands review and repair skills based on execution issues, completing the creation and maintenance cycle within Claude Code.

### What is the difference between TACHES commands and skills?

According to the README, commands are slash commands that expand into structured workflows, while skills are autonomous workflows that can research, generate, and self-heal. Commands tend to be single-step structured prompts, while skills are multi-step workflows that can use sub-agents and produce files as output.

## Sources

- [glittercowboy/taches-cc-resources on GitHub](https://github.com/glittercowboy/taches-cc-resources)
- [Issues](https://github.com/glittercowboy/taches-cc-resources/issues)
- [License: MIT](https://github.com/glittercowboy/taches-cc-resources/blob/main/LICENSE)
- [Project website](https://youtube.com/tachesteaches)
- [README](https://github.com/glittercowboy/taches-cc-resources/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/glittercowboy-taches-cc-resources