convez.ai
SkillDesenvolvimento WebIntermediário
jagreehal

Padrões TypeScript e Skills para Claude Code

jagreehal/jagreehal-claude-skills

Padrões TS e workflows para código produção com Claude Code

Ver no GitHub
InicialPluginScore · de 0 a 100

Coleção de skills e plugins opinionados que implementam padrões de arquitetura TypeScript de nível produção para desenvolvimento assistido por IA. Inclui 10 plugins temáticos (padrões core, TDD, React, DevOps, documentação) que você instala conforme precisa, com suporte a hooks e automação.

Instalação

$npx convez-ai jagreehal/jagreehal-claude-skills

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
3
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 3 meses
Versão
—
Issues abertas
1
Contribuidores
1

Casos de uso

  • Estruturar projetos TypeScript com arquitetura testável e escalável
  • Implementar TDD e test pyramid com vitest
  • Automatizar code review e análise de debugging
  • Configurar workflows de produtividade com git worktrees e agentes paralelos
  • Padrões React, Storybook e design de UI

Veredito

Recurso bem estruturado para times que querem elevar a qualidade arquitetural do código TypeScript com Claude Code. A modularidade em plugins é uma vantagem, mas exige disciplina e entendimento real dos padrões — não é um atalho para bom design.

README

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

jagreehal-claude-skills

Opinionated TypeScript patterns for AI-assisted development. Skills, commands, and hooks for Claude Code that enforce production-grade architecture.

Installation

From Marketplace

# Add the marketplace
/plugin marketplace add jagreehal/jagreehal-claude-skills

# List available plugins
/plugin list jagreehal-marketplace

# Install only what you need
/plugin install <plugin-name>@jagreehal-marketplace

Available Plugins

This marketplace contains 10 plugins. Install only what you need.

PluginSkillsDescription
typescript-patterns9Core TS architecture: fn(args, deps), Result types, Zod, observability
testing-tdd4TDD workflow: red-green-refactor, test pyramid, performance testing
communication-behavior6Claude style: critical peer, concise output, research-first
workflow-productivity10Session management, verification, git worktrees, parallel agents
frontend-react4React patterns, Storybook, UI design, browser automation
documentation-architecture5Documentation standards, ADRs, data visualization
debugging-analysis2Evidence-based debugging, code flow analysis
skill-authoring1Guide for creating custom skills
code-review-Auto code review on file modifications (hooks)
track-and-improve-5 whys root cause analysis for mistakes

Quick Start Examples

# TypeScript developer wanting core patterns + TDD
/plugin install typescript-patterns@jagreehal-marketplace
/plugin install testing-tdd@jagreehal-marketplace

# Frontend developer
/plugin install frontend-react@jagreehal-marketplace
/plugin install typescript-patterns@jagreehal-marketplace

# Want Claude to be more concise and research-driven
/plugin install communication-behavior@jagreehal-marketplace

# Full productivity workflow
/plugin install workflow-productivity@jagreehal-marketplace

Manual Configuration

Add to your .claude/settings.local.json:

{
  "extraKnownMarketplaces": {
    "jagreehal-marketplace": {
      "source": {
        "source": "github",
        "repo": "jagreehal/jagreehal-claude-skills"
      }
    }
  },
  "enabledPlugins": {
    "typescript-patterns@jagreehal-marketplace": true,
    "testing-tdd@jagreehal-marketplace": true
  }
}

Plugin Details

typescript-patterns (9 skills)

Core TypeScript architecture patterns for production-grade code.

SkillDescription
fn-args-depsCore pattern: fn(args, deps) for testable functions
validation-boundaryZod schemas at boundaries, trust inside
result-typesNever throw - use Result<T, E> with workflows
strict-typescriptBeyond strict: true - advanced types, ESLint enforcement
config-managementValidate config at startup, secrets in memory only
api-designProduction-ready HTTP APIs with clean handlers, error envelopes
pattern-enforcementESLint rules that fail the build
resilienceRetry/timeout at workflow level, not in functions
observabilitytrace() wrapper, Pino logging, OpenTelemetry

testing-tdd (4 skills)

TDD workflow and comprehensive testing strategies.

SkillDescription
tdd-workflowRed-green-refactor with Result type testing
testing-strategyTest pyramid with vitest-mock-extended
writing-testsTest naming, assertions, edge case checklists (BugMagnet-based)
performance-testingLoad testing, chaos engineering, trace correlation

communication-behavior (6 skills)

How Claude communicates and behaves during sessions.

SkillDescription
critical-peerProfessional skepticism, concise output, research first
concise-outputMaximum information density, eliminate filler phrases
confidence-levelsExpress confidence as %, explain gaps, show evidence
research-firstValidate solutions before presenting, never ask lazy questions
literal-answersTreat questions as literal questions, answer honestly
answer-questions-directlyAnswer questions literally, don't interpret as instructions

workflow-productivity (10 skills)

Session management, task tracking, and development workflow.

SkillDescription
session-continuityPersist tasks across sessions with .claude/ files
investigation-modesLEARNING/INVESTIGATION/SOLVING with explicit transitions
verification-before-completionRun verification commands before claiming work complete
design-explorationExplore user intent collaboratively before implementation
implementation-planningCreate bite-sized TDD task plans with exact file paths
git-worktreesCreate isolated git worktrees for feature work
parallel-agent-dispatchDispatch multiple agents in parallel for independent tasks
code-review-receptionHandle code review feedback with technical verification
branch-completionGuide completion of development work with verification
create-tasksCreate well-formed tasks with context and acceptance criteria

frontend-react (4 skills)

Frontend development with React and modern tooling.

SkillDescription
react-developmentModern React patterns, technology stack, accessibility
storybook-journeysStorybook user journey storyboards with MSW API mocking
ui-design-principlesDesign systems, implementation-ready interfaces
agent-browserBrowser automation for web testing, form filling, screenshots

documentation-architecture (5 skills)

Documentation standards and system architecture decisions.

SkillDescription
documentation-standards8 quality dimensions, user-centered documentation
system-architectureTrade-off analysis, ADRs, pattern selection
structured-writingVoice preservation, gap identification
data-visualizationChart selection, encoding hierarchy, accessibility
design-principlesFail-fast, no any, domain naming, YAGNI

debugging-analysis (2 skills)

Evidence-based debugging and code analysis.

SkillDescription
debugging-methodologyEvidence-based debugging with instrumentation
code-flow-analysisTrace execution paths before implementing

skill-authoring (1 skill)

Meta-skill for creating your own Claude Code skills.

SkillDescription
skill-authoringGuide for creating, editing, and reviewing skills

code-review

Automatic code review triggered on file modifications. Uses hooks to review against project-specific rules aligned with TypeScript patterns.

track-and-improve

Capture mistakes and improvement opportunities with 5 whys root cause analysis. Learn from patterns to prevent future issues.


Commands

CommandDescription
/scaffold-function <name>Generate fn(args, deps) function with tests
/verify-patternsQuick check for pattern violations
/full-review [--report] [--scope <path>]Comprehensive codebase review with detailed report
/init-projectSet up new project with patterns
/learn-from-prs [--count <n>] [--state <state>]Analyze PR feedback patterns and suggest config updates
/workflow <mode|off>Set collaboration mode: STEP-BY-STEP, DEEP-THINK, or PAIR
/track-improve <description>Capture mistake or improvement with 5 whys root cause analysis

Agents

AgentDescription
pattern-checkerAutonomous agent that scans codebase for pattern violations
task-checkVerifies task completion with context-aware standards

Core Libraries

LibraryPurpose
zodSchema validation at boundaries
@jagreehal/workflowResult types and workflow composition
autotelOpenTelemetry trace() wrapper
pinoStructured logging (5x faster than Winston)
vitest-mock-extendedTyped mocks from deps interfaces
@total-typescript/ts-resetFix JSON.parse returning any
type-festUtility types
k6Load testing and performance validation
node-env-resolverConfiguration validation and secret management

The Pattern

// 1. Define explicit deps type
type GetUserDeps = { db: Database; logger: Logger };

// 2. Function takes (args, deps), returns Result
async function getUser(
  args: { userId: string },
  deps: GetUserDeps
): Promise<Result<User, 'NOT_FOUND' | 'DB_ERROR'>> {
  const user = await deps.db.findUser(args.userId);
  return user ? ok(user) : err('NOT_FOUND');
}

// 3. Validate at boundary with Zod
const GetUserSchema = z.object({ userId: z.string().uuid() });

// 4. Handler maps Result to HTTP
app.get('/users/:id', async (req, res) => {
  const parsed = GetUserSchema.safeParse(req.params);
  if (!parsed.success) return res.status(400).json(formatZodError(parsed.error));

  const result = await getUser(parsed.data, deps);
  return resultToResponse(result, res);
});

Architecture

HTTP Handlers
  -> validate with Zod, map Result to HTTP

Workflows
  -> createWorkflow({ ... })(step => { ... })
  -> step.retry(), step.withTimeout()

Business Functions
  -> fn(args, deps): Result<T, E>
  -> wrapped with trace()

Infrastructure
  -> postgres, redis, http (just transport)

Philosophy

  • Explicit over implicit - Dependencies visible in signatures
  • Parse, don't validate - Transform to types that can't be invalid
  • Never throw - Errors are values, not exceptions
  • Composition over inheritance - Workflows compose functions
  • Rules over rituals - ESLint enforces patterns, not documentation

Based On

These patterns are derived from arrangeactassert.com TypeScript architecture posts.

Ver o original no GitHub

Bom para

Relacionados