convez.ai
PluginAutomaçãoIntermediário
Brite-Nites

Brite Claude Plugins

Brite-Nites/brite-claude-plugins

Workflow estruturado com Linear para engenharia em equipe no Claude Code

Ver no GitHub
InicialPluginScore · de 0 a 100

Bundle de plugins para Claude Code que implementa metodologia estruturada de workflow (brainstorm → plano → execução → review → ship) integrada com Linear. Fornece comandos de processo organizacional e execução de tarefas com TDD, subagents e rastreamento de decisões para equipes de engenharia.

Instalação

$npx convez-ai Brite-Nites/brite-claude-plugins

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
37%
Último commit
há 2 dias
Versão
—
Issues abertas
17
Contribuidores
6

Casos de uso

  • Padronizar processo de desenvolvimento em equipes
  • Integrar planejamento Linear com execução de código
  • Executar revisões de código e auditoria em paralelo
  • Rastrear decisões e composição de conhecimento entre projetos

Veredito

Plugin maduro focado em metodologia de processo mais que ferramental específica. Útil para equipes que já usam Linear e buscam estruturar workflows em Claude Code, mas requer alinhamento organizacional para valor real. Arquitetura de camadas promissora, embora ainda em evolução.

README

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

Brite Claude Plugins

A Process + Org plugin for Claude Code. Superpowers methodology + compound engineering + Linear integration — structured workflow (brainstorm → plan → worktree → execute → review → compound → audit) with Linear woven into every step.

Current version: 3.24.0 | Changelog | Roadmap

Philosophy

This plugin teaches how to work, not what to know about specific technologies:

session-start → brainstorm → plan → [worktree] → execute (subagent + TDD) → review → ship (compound + audit)
       ↑                                                                                         |
       └───────────────────── scope (creative discovery) ←───────────────────────────────────────┘
  • Process: Superpowers' full workflow with TDD, subagent-per-task execution, and compound knowledge
  • Org: Linear integration at every step, security hooks, team conventions
  • Domain skills are separate plugins — tech-stack knowledge lives in dedicated domain plugins

Influenced by superpowers and compound-engineering. See the Roadmap for what's coming next.

Vision: Brite Agent Platform

This plugin is evolving into a four-layer platform for universal project routing, domain-specific knowledge, structured workflows, and autonomous execution.

LayerMilestoneWhat it delivers
KnowledgeCompany Knowledge LayerHandbook repo as company brain — CDRs, context, precedents
RoutingProject-Start RedesignTrait-based classification routes any project type
TracesDecision Trace ArchitectureStructured reasoning traces compound into searchable precedents
PluginsPlugin EcosystemDomain plugins (marketing, engineering, design, sales, product)
RefreshContext Refresh PipelineAutomated BigQuery + Salesforce → handbook context
AutonomousSymphony ExecutionAgents execute Linear issues autonomously
GovernanceContext GovernanceQuality dashboards, CDR governance, flywheel monitoring

See the Platform Design Document for the full PRD.

Prerequisites

  • Claude Code CLI installed
  • Node.js 18+ (for MCP servers)

Quick Start

Install the plugin bundle:

claude plugins add https://github.com/Brite-Nites/brite-claude-plugins

Or manually add to your .claude/settings.json:

{
  "plugins": [
    {
      "source": "https://github.com/Brite-Nites/brite-claude-plugins",
      "plugins": ["workflows"]
    }
  ]
}

Verify installation by typing /workflows: in Claude Code — you should see the available commands in the slash menu.

Available Commands

Core workflow (the inner loop):

CommandDescription
/workflows:session-startStart a work session — pick a Linear issue, brainstorm, plan, execute
/workflows:reviewRun review agents in parallel, fix P1s, report findings
/workflows:shipCreate PR, update Linear, compound learnings, best-practices audit

Direction-setting:

CommandDescription
/workflows:scopeCollaborative scoping session — discover what to build, create Linear issues
/workflows:project-startStart a new project with a guided interview
/workflows:sprint-planningPlan sprint and assign issues to a cycle
/workflows:retrospectiveSprint retrospective with status update

Utilities:

CommandDescription
/workflows:code-reviewStandardized code review for Brite projects
/workflows:security-auditComprehensive project security audit
/workflows:raise-a-ticketReport a bug or idea/feedback on a Brite product — routes to the right Linear team/project, files as needs-triage
/workflows:bug-reportDeprecated — use /workflows:raise-a-ticket
/workflows:deployment-checklistPre-deployment validation checklist
/workflows:tech-stackDisplay the Brite technology stack
/workflows:onboarding-checklistGuide for setting up a new dev environment
/workflows:setup-claude-mdGenerate best-practices CLAUDE.md for a project
/workflows:architecture-decisionGenerate Architecture Decision Records
/workflows:create-pluginScaffold a new domain plugin from template
/workflows:smoke-testDiagnostic checks on plugin environment

Quality:

CommandDescription
/workflows:fact-checkVerify factual accuracy of a document against the codebase

Skill Coverage Matrix

Skills activate automatically when Claude detects relevant context.

Inner Loop skills (auto-activate in sequence):

SkillCategoryTrigger
brainstormingDiscoveryNon-trivial issue, before planning
writing-plansPlanningMulti-step task, before coding
git-worktreesSetupAfter plan approval, before coding
executing-plansExecutionGiven an approved plan to implement
verification-before-completionQualityTask checkpoints during execution
compound-learningsKnowledgeAfter completing work (via ship)
best-practices-auditQualityAfter compound learnings (via ship)
systematic-debuggingDebuggingBug investigation (anytime)

Design, backend & quality skills (shipped):

SkillCategoryTrigger
react-best-practicesFrontendWriting, reviewing, or optimizing React components
python-best-practicesBackendWriting, reviewing, or refactoring FastAPI/Python code
frontend-designFrontendBuilding web components, pages, dashboards
ui-ux-pro-maxDesignDesign tasks across 50 styles, 9 frameworks, 21 palettes
web-design-guidelinesDesignReviewing UI code for best practices and accessibility
code-qualityQualityESLint, Prettier, Ruff, TypeScript strict enforcement
testing-strategyQualityTesting patterns for Vitest, RTL, MSW, and Playwright
agent-browserAutomationNavigating websites, filling forms, taking screenshots
find-skillsDiscoveryLooking for new skills or capabilities to install

Review Agents

/workflows:review runs up to 9 specialized review agents in parallel:

TierAgentsActivation
1 (always)code-reviewer, security-reviewer, performance-reviewerEvery review
2 (stack)typescript-reviewer, python-reviewer, data-reviewerAuto-detected from project files
3 (opt-in)architecture-reviewer, accessibility-reviewer, test-quality-reviewerLarge projects or CLAUDE.md include

Depth modes: fast (Tier 1 only), thorough (default, Tier 1+2), comprehensive (all tiers). All agents run on Opus. A Haiku-powered diff-triage agent gates trivial diffs.

Workflow skills (shipped):

SkillCategoryTrigger
post-plan-setupWorkflowAfter /workflows:project-start produces a v1 plan (orchestrates 3 phases)
refine-planWorkflowDecomposes v1 plans into agent-ready tasks (internal)
create-issuesWorkflowCreates Linear issues from refined plans (internal)
setup-claude-mdWorkflowGenerates best-practices CLAUDE.md for a project (internal)

MCP Servers

The plugin configures two MCP servers automatically:

ServerTransportPurpose
sequential-thinkingstdioStructured reasoning via @modelcontextprotocol/server-sequential-thinking
linear-serverHTTPLinear project management integration

The Linear MCP server provides tools for managing issues, projects, milestones, and documentation directly from Claude Code.


Plugin Development Guide

Repository Structure

.claude-plugin/
  marketplace.json          # Plugin registry (required for bundles)
plugins/
  workflows/
    .claude-plugin/
      plugin.json           # Plugin metadata
    commands/               # Slash commands
    skills/                 # Model-invoked skills
    agents/                 # Specialized subagents
    hooks/                  # Event handlers
    .mcp.json               # MCP server configurations

Plugin Manifest (plugin.json)

Each plugin requires .claude-plugin/plugin.json:

{
  "name": "workflows",
  "description": "Process + Org plugin — structured workflow methodology with Linear integration",
  "version": "3.24.0",
  "author": { "name": "Brite" },
  "homepage": "https://github.com/brite-nites/brite-claude-plugins",
  "repository": "https://github.com/brite-nites/brite-claude-plugins",
  "license": "MIT",
  "keywords": ["claude-code", "plugin", "process", "workflow", "linear"],
  "commands": "./commands/",
  "skills": "./skills/"
}

Adding Commands

Commands are slash commands that users invoke directly. Create a markdown file in commands/.

File Structure

commands/
  my-command.md      # Becomes /workflows:my-command

Command Format

---
description: Brief description shown in slash menu
---

Instructions for Claude on how to handle this command.

Use $ARGUMENTS for the full user input after the command.
Use $1, $2, etc. for positional arguments.

Example: Deploy Command

commands/deploy.md:

---
description: Deploy the current project to production
---

You are deploying the user's project. Follow these steps:

1. Run all tests to ensure the build is stable
2. Build the production bundle
3. Deploy using the configured deployment method

The user specified: $ARGUMENTS

Adding Skills

Skills are model-invoked capabilities that Claude uses automatically based on context. Unlike commands, users don't invoke skills directly — Claude decides when to use them.

File Structure

skills/
  code-review/
    SKILL.md           # Required: Skill definition
    templates/         # Optional: Supporting files
  security-scan/
    SKILL.md

SKILL.md Format

---
name: code-review
description: When to use this skill - Claude reads this to decide
allowed-tools: Read, Grep, Glob
user-invocable: true
---

# Code Review Skill

Detailed instructions for how Claude should perform this skill.

## When to Activate
- User asks for code review
- PR review is requested
- Code quality assessment needed

## Process
1. First step...
2. Second step...

Frontmatter Options

FieldDescription
nameSkill identifier (required)
descriptionWhen/why Claude should use this skill (required)
allowed-toolsTools Claude can use without asking permission
modelSpecific model to use (e.g., haiku, sonnet)
context: forkRun in isolated sub-agent
agentAgent type when using context: fork
user-invocableShow in slash menu (default: true)

Adding MCP Server Configurations

MCP (Model Context Protocol) servers connect Claude to external tools, APIs, and databases.

File Location

Create .mcp.json at the plugin root:

plugins/
  workflows/
    .mcp.json           # MCP configuration

Configuration Format

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["@brite/mcp-database"],
      "env": {
        "DB_PATH": "${CLAUDE_PLUGIN_ROOT}/data"
      }
    },
    "api-client": {
      "command": "${CLAUDE_PLUGIN_ROOT}/servers/api-server.js",
      "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"]
    }
  }
}

Path Variables

VariableDescription
${CLAUDE_PLUGIN_ROOT}Absolute path to the plugin directory

Transport Types

stdio (default):

{
  "mcpServers": {
    "local-server": {
      "command": "./server.js",
      "args": []
    }
  }
}

HTTP/SSE:

{
  "mcpServers": {
    "remote-server": {
      "url": "https://api.example.com/mcp",
      "transport": "sse"
    }
  }
}

Adding Hooks

Hooks respond to Claude Code events automatically (formatting, validation, notifications).

File Location

Create hooks/hooks.json or define inline in plugin.json:

plugins/
  workflows/
    hooks/
      hooks.json

Hook Events

EventWhen it fires
PreToolUseBefore Claude uses any tool
PostToolUseAfter tool execution
PostToolUseFailureAfter a tool fails
UserPromptSubmitWhen user submits a prompt
StopWhen Claude attempts to stop
SessionStartWhen a session begins
SessionEndWhen a session ends

Configuration Format

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "${CLAUDE_PLUGIN_ROOT}/scripts/format.sh $CLAUDE_FILE_PATH"
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "prompt",
            "prompt": "Verify this command is safe to run"
          }
        ]
      }
    ]
  }
}

Hook Types

TypeDescription
commandExecute a shell command/script
promptLLM-based evaluation (uses Haiku)
agentFull agent with tool access

Adding Agents

Agents are specialized subagents that Claude can delegate tasks to.

File Structure

agents/
  security-reviewer.md
  performance-tester.md

Agent Format

---
description: What this agent specializes in
capabilities:
  - security analysis
  - vulnerability detection
  - compliance checking
skills: security-scan, code-review
---

# Security Reviewer Agent

You are a security specialist. When delegated tasks:

1. Review code for security vulnerabilities
2. Check for OWASP Top 10 issues
3. Validate input sanitization
4. Report findings with severity levels

Adding Output Styles

Output styles customize Claude's response format and behavior.

File Structure

styles/
  concise.md
  verbose.md

Style Format

---
name: Concise Mode
description: Short, direct responses
keep-coding-instructions: true
---

Respond concisely. Use bullet points. Avoid lengthy explanations.
Maximum 3 sentences per response unless more detail is explicitly requested.

Marketplace Configuration

The root marketplace.json registers plugins for distribution:

{
  "name": "brite-claude-plugins",
  "owner": {
    "name": "Brite"
  },
  "metadata": {
    "description": "Claude Code plugins for the Brite organization"
  },
  "plugins": [
    {
      "name": "workflows",
      "source": "./plugins/workflows",
      "description": "Process + Org plugin — structured workflow methodology with Linear integration",
      "version": "3.24.0"
    }
  ]
}

To add a new plugin to the bundle, create the plugin directory and add it to the plugins array.


Documentation

DocumentDescription
ARCHITECTURE.mdSystem diagrams, runtime flow, skill routing, design decisions
CONTRIBUTING.mdHow to add commands, skills, agents, hooks; branch and PR conventions
docs/getting-started.mdDeveloper setup for working on this repo
docs/workflow-guide.mdFull workflow walkthrough, skill reference, visual features
docs/troubleshooting.mdCommon issues and solutions
CHANGELOG.mdVersion history
ROADMAP.mdDevelopment plan and lifecycle vision
CLAUDE.mdInstructions for Claude Code when working in this repo

Contributing

See CONTRIBUTING.md for the full contributor guide, including:

  • Step-by-step instructions for adding commands, skills, agents, and hooks
  • SKILL.md frontmatter standard
  • Branch naming and commit message conventions
  • CI checks and local testing

License

MIT

Issue Tracking

Issues for this project are tracked in Brite Skill Packs (Layer C). Sibling Linear projects under the same initiative: Brite Orchestration Layer, Brite Knowledge Layer, Brite Runtime & Harness.

Ver o original no GitHub

Bom para

Relacionados