convez.ai
SkillAutomaçãoIntermediário
torqlab

TORQ Claude Collection

torqlab/claude

Configurações compartilhadas e skills para desenvolvimento agentic estruturado

Ver no GitHub
InicialPluginScore · de 0 a 100

Coleção centralizada de configurações, skills e hooks do Claude para desenvolvimento ágil com agentes. Implementa o workflow de Addy Osmani com skills especializadas para cada fase de desenvolvimento, garantindo consistência em projetos TORQ via symlinks.

Instalação

$npx convez-ai torqlab/claude

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
25%
Último commit
há 4 meses
Versão
—
Issues abertas
1
Contribuidores
1

Casos de uso

  • Padronizar workflows de desenvolvimento com agentes Claude em múltiplos repositórios
  • Implementar metodologia Addy Osmani com fases especializadas (idea-refine, design, build, review)
  • Compartilhar skills customizadas de versionamento semântico, gerenciamento de branches e criação de PRs
  • Manter consistência de configurações e convenções em equipes de desenvolvimento

Veredito

Ferramenta robusta para times que usam Claude Code em múltiplos projetos e precisam de padronização. O suporte a symlinks elimina duplicação de configurações, e o workflow Addy Osmani é bem estruturado, mas requer buy-in metodológico do time para máximo valor.

README

A tradução para o português deste README ainda está na fila.

TORQ Claude Configuration Collection

A shared collection of Claude configurations, skills, hooks, and conventions for the TORQ project. This repository provides a unified set of AI development tools used across multiple TORQ repositories via symlinks.

Overview

This is a project-level Claude collection that serves as a centralized source of truth for Claude development practices. Every TORQ repository can reference this collection via a symlink, ensuring consistent configurations, skills, and conventions across all projects.

Primary Development Methodology: This collection uses Addy Osmani's agent-skills workflow as the foundation for structured, collaborative development. This proven framework breaks work into clear phases with specialized agents, testing strategies, and quality gates—enabling faster iteration while maintaining code quality and reliability.

Key purpose: Enable standardized AI-driven development workflows, code generation, and automation while maintaining quality standards through shared hooks, rules, and custom skills.

What's Included

  • SKILLS.md — Complete reference for all available skills organized by type (custom, open-source, agent skills) with decision trees for workflow selection
  • Addy Osmani Workflow — Structured development methodology with specialized agents for each phase
  • Custom Skills — Project-specific skills for semantic versioning, branch management, PR creation, and documentation
  • Configurations — Claude Code settings, hooks, and project conventions in .claude/
  • Documentation — Setup guides, workflow patterns, and integration examples

Quick Start: Using This Collection in Your Project

Installation

Every TORQ repository can use this collection via a symlink to .claude. This ensures consistent configurations, skills, and conventions across all projects.

Step 1: Create the Symlink

From your TORQ repository directory, create a symlink to this collection's .claude directory:

# Absolute path
ln -s /path/to/torq/claude/.claude .claude

# Or relative path (if torq/claude is a sibling)
ln -s ../claude/.claude .claude

Step 2: Verify the Symlink

Confirm the symlink works:

ls -l .claude
# Should show: .claude -> ../claude/.claude (or absolute path)

Step 3: Configure Git (Optional but Recommended)

Add .claude to .gitignore:

# Claude Code
.claude

Then optionally commit the symlink itself (Git handles symlinks correctly):

git add .claude
git commit -m "Add Claude configuration collection via symlink"

Step 4: Skills and Plugins Ready to Use

Claude Code will automatically discover and load:

  • ✅ All custom skills from .claude/skills/
  • ✅ All open-source skills from skills-lock.json
  • ✅ All enabled plugins (agent-skills@addy-agent-skills)
  • ✅ Settings from .claude/settings.json

No additional setup needed — start using Claude Code as normal!

🎯 Addy Osmani Workflow: Primary Development Methodology

This collection implements Addy Osmani's agent-skills framework as the core development workflow. This structured approach breaks complex work into clear phases with specialized agents, ensuring quality, testing, and iterative improvement at each stage.

Core Workflow Phases

PhaseAgent SkillPurposeCommand
Idea Refinement/idea-refineRefine raw concepts into sharp, actionable requirements/idea-refine
Code Review/review or /code-review-and-qualityFive-axis review (correctness, readability, architecture, security, performance)/review

Essential Commands & Shortcuts

Start with requirements:

/spec          # Spec-driven development - write before coding
/interview-me  # Extract real requirements
/idea-refine   # Refine vague ideas into actionable specs

Implement & build:

/plan          # Break spec into ordered tasks
/build         # Implement incrementally
/test          # Run TDD workflow (failing tests first)

Quality gates:

/review        # Five-axis code review
/ship          # Pre-launch checklist

Supporting tools:

/source-driven-development    # Ground decisions in documentation
/doubt-driven-development     # Adversarial review of decisions
/debugging-and-error-recovery # Systematic debugging
/performance-optimization     # Profile and optimize
/security-and-hardening       # Vulnerability hardening

Typical Development Flow

1. Start with unclear requirements
   → /interview-me or /idea-refine
   
2. Write specification
   → /spec
   
3. Plan the work
   → /plan (breaks into tasks)
   
4. Build incrementally
   → /build (implement → test → verify → commit)
   
5. Code review
   → /review (five-axis review)
   
6. Launch
   → /ship (pre-launch checklist)

When to Use Each Agent

  • Uncertain requirements? Start with /interview-me or /idea-refine
  • Starting new feature? Use /spec to write requirements first
  • Have specs/requirements? Use /plan to break into tasks
  • Implementing a task? Use /build for incremental cycles
  • Bug or test failure? Use /test for TDD or /debugging-and-error-recovery
  • Before merge? Use /review for quality gate
  • Going to production? Use /ship for final checklist

Common Workflows

Typical development patterns using the agent-skills workflow:

Workflow 1: Start with Unclear Requirements

  1. Use /idea-refine or /interview-me to clarify scope
  2. Write specification with /spec
  3. Plan with /plan to break into tasks
  4. Implement with /build
  5. Test with /test (TDD approach)
  6. Review with /review before merge
  7. Launch with /ship when ready

Workflow 2: Implement a Known Feature

  1. Have specifications ready
  2. Use /plan to organize tasks
  3. Use /build to implement incrementally
  4. Use /test for test-driven development
  5. Use /review for quality gate
  6. Use /ship before production

Workflow 3: Debug or Fix an Issue

  1. Use /debugging-and-error-recovery for systematic root-cause analysis
  2. Use /test to create failing test first
  3. Fix and verify with /build
  4. Use /review before merge

Workflow 4: Optimize Performance

  1. Use /performance-optimization to profile and identify bottlenecks
  2. Implement optimizations with /build
  3. Test improvements with /test
  4. Use /review before merge

Workflow 5: Add Security Hardening

  1. Use /security-and-hardening for vulnerability analysis
  2. Implement fixes with /build
  3. Test with /test
  4. Use /ship or /review before deployment

Agent Combinations & Context Flow

Common agent workflow sequences and how context flows between them:

SequencePrerequisitesPurposeOutput Context
/interview-me → /specUnclear requirementsClarify and document requirementsDetailed specification
/spec → /plan → /buildClear specificationFeature development workflowPlanned tasks → Implementation
/plan → /build → /test → /reviewTask listComplete build cycleCode changes → Tests → Review feedback
/test → /build → /review → /shipFailing testBug fix and deploymentTest fix → Reviewed code → Production ready
/debugging-and-error-recovery → /test → /buildError symptomsSystematic debuggingRoot cause → Failing test → Fix
/performance-optimization → /build → /testPerformance baselinePerformance improvementOptimization strategy → Implemented → Verified
/security-and-hardening → /build → /test → /reviewSecurity auditSecurity hardeningHardening strategy → Implementation → Verification
/api-and-interface-design → /build → /testAPI requirementsStable interface designAPI design → Implementation → Tests
/code-review-and-quality → /shipCode ready for reviewFinal quality gate before shipReview feedback → Ship checklist
/doubt-driven-development → /buildNon-trivial decisionAdversarial review of designQuestioned assumptions → Confirmed approach
/documentation-and-adrs → /buildArchitectural decisionRecord decision and implementADR → Implementation

Context flows left-to-right: Output from one agent becomes the input context for the next agent in the sequence.

Reference: Addy Osmani's agent-skills repository

Adding Skills to This Collection

Project-Specific Skills

This collection provides custom skills for semantic versioning, branch management, and documentation:

SkillPurposeUsage
semantic-releaseAgent-driven workflow for creating git branches and conventional commits aligned with semantic versioning/semantic-release
git-branchCreate git branches with semantic-release naming conventions for the current repository/git-branch
prAgent-driven GitHub PR creation workflow aligned with semantic-release conventions/pr
github-mcp-setupConfigure GitHub Model Context Protocol (MCP) server for Claude Code using GitHub App authentication/github-mcp-setup
document-skillsDiscovers all available skills and generates a dedicated SKILLS.md file in the project root with a comprehensive table organized by skill type/document-skills

Skill Integration with Agent Workflow

How custom project-specific skills integrate with agent-skills:

SkillIntegration PointWorks With AgentsSequence
semantic-releaseDuring /plan → /build/plan, /build/plan → /semantic-release (create branch) → /build
git-branchAt start of /build/plan, /build/plan → /git-branch (create) → /build
prAfter /build when ready for review/build, /review, /ship/build → /review → /pr (create) → /ship
github-mcp-setupBefore any /pr usage/prSetup first, then use /pr
document-skillsBefore releases or during maintenanceAny workflowUse after adding new skills

Integration strategy:

  • Branch creation: Use /semantic-release or /git-branch early in /build phase
  • Code review integration: /review provides feedback context for /pr creation
  • Release workflow: Complete /build → /review → /pr → /ship sequence
  • Documentation: Keep /document-skills up to date after skill additions

Open-Source Skills (from NPM)

Skills from Anthropic's anthropics/skills are managed via npx skills and skills-lock.json:

{
  "version": 1,
  "skills": {
    "my-skill": {
      "source": "anthropics/skills",
      "ref": "main",
      "sourceType": "github",
      "skillPath": "skills/my-skill/SKILL.md"
    }
  }
}

Custom Project-Specific Skills

Add custom skills to .claude/skills/<skill-name>/:

.claude/skills/my-skill/
├── SKILL.md                 # Main skill definition
├── references/              # Documentation files
│   ├── guide.md
│   └── examples.md
├── scripts/                 # Reusable helper scripts
│   └── helper.py
└── assets/                  # Templates, icons, etc.

SKILL.md frontmatter (required):

---
name: my-skill
description: When to use this skill and what it does. Make descriptions clear about trigger contexts.
license: MIT
metadata:
  author: Your Name
---

Repository Structure

torq/claude/
├── .claude/
│   ├── skills/              # Custom project-specific skills
│   │   ├── github-mcp-setup/
│   │   └── skill-creator/   # Imported from anthropics/skills
│   ├── settings.json        # Plugin configuration
│   └── settings.local.json  # Local overrides
├── README.md                # This file
├── AGENTS.md                # Agent setup guide
├── package.json             # Project metadata
├── skills-lock.json         # Open-source skills registry
└── .nvmrc                   # Node version specification

Support & Contributions

For issues or questions:

To add a new skill:

  1. Create a directory in ./.claude/skills/<skill-name>/
  2. Write SKILL.md with proper frontmatter
  3. Include documentation in references/ and helper scripts in scripts/
  4. Test with the skill-creator skill

Version & Metadata

Repository: @torqlab/claude
License: MIT
Maintainer: Mr.B.Lab
Node: 24.x


Last updated: 2026-06-09

Ver o original no GitHub

Bom para

Relacionados