Skip to main content
skill CX Codex

pcl-expert — Claude Code skill: PCL language and compiler

pcl-expert — a skill for Persona Control Language: persona, team and workflow declarations, the compiler pipeline, the pcl toolchain. Useful when the agent edits .pcl files or the compiler itself.

Apache-2.0 160 installs ★ 45 updated 2026-10-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add personamanagmentlayer/pcl --skill pcl-expert -a claude-code
Open on GitHub

What pcl-expert does

The skill loads domain knowledge about Persona Control Language, a DSL and compiler aimed at AI persona management. It covers four declaration forms: persona, team, workflow and skill, each with syntax samples. On the compiler side it maps the pipeline from lexer through parser and semantic analysis to code generation, and touches LSP and MCP integration.

A good chunk of the text is a CLI map. The agent gets pcl build and pcl watch for compilation, pcl run and pcl repl for execution, the pcl skills group for listing, installing, publishing and validating, plus pcl registry, pcl lsp, pcl mcp and pcl serve, which brings up an HTTP artifact registry with JWT auth and rate limiting. Its allowed tools are Read, Write, Edit, Execute, Debug, Test, so it can change code rather than only talk about it.

There is an anti-patterns section with a clear stance: no global state, no throw where a Result<AST, Error[]> fits, no mutable AST, no any. That stance has teeth. On a parser built around exceptions the agent will push toward result types instead of matching your existing style.

What it helps with

  • sketch a team with per-persona weights and consensus merge mode
  • chain workflow steps so one persona's output feeds the next
  • define the grammar for a new PCL operator and the AST nodes it needs
  • start the language server with pcl lsp and wire it into an editor
  • move a parser off exceptions onto Result without global state

Example prompts for the agent

  • Add a CODE_REVIEW_TEAM to personas.pcl: three personas, weights 0.5, 0.3 and 0.2, merge mode consensus.
  • pcl build fails somewhere in the type check — trace which AST nodes lose their type.
  • Write the grammar for a new PCL operator, update the lexer and parser, then run pcl build.

How to install pcl-expert

1Skills CLI (Vercel)

npx skills add personamanagmentlayer/pcl --skill pcl-expert -a claude-code

2Manually: put the files in place

~/.claude/skills/pcl-expert/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/pcl-expert/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about pcl-expert

How do I install pcl-expert in Claude Code?

Run npx skills add personamanagmentlayer/pcl --skill pcl-expert -a claude-code. The skill lands at ~/.claude/skills/pcl-expert/SKILL.md.

What does pcl-expert do?

It briefs the agent on PCL and its compiler: the persona, team and workflow declarations, the lexer and parser, and the pcl CLI with its registry commands.

Which coding habits does the skill reject?

Global state, exceptions where Result fits, mutable AST nodes and untyped any. Code that leans on them gets rewritten during edits.

Source text

SKILL.md · Apache-2.0
---
name: pcl-expert
version: 1.1.0
description: >-
  Expert in Persona Control Language (PCL) - language design, compiler architecture,
  runtime systems, and ecosystem development. Use when the user mentions persona control
  language, compiler design, language design, DSL, runtime systems, or lexer, or when the
  task involves Language Design & Specification, Compiler Architecture, Language Server
  Protocol, or Model Context Protocol.
category: languages
tags:
  [
    pcl,
    persona-control-language,
    compiler-design,
    language-design,
    dsl,
    runtime-systems,
    lexer,
    parser,
    semantic-analysis,
    codegen,
    type-systems,
    ast,
    lsp,
    mcp,
  ]
allowed-tools:
  - Read
  - Write
  - Edit
  - Execute
  - Debug
  - Test
---

# PCL Expert

Master expert in **Persona Control Language (PCL)** - a domain-specific programming language and compiler for AI persona management. Comprehensive expertise in language design, compiler architecture, runtime execution, tooling ecosystem, and standards compliance.

## Advanced Features

### Adaptive Intelligence (Phase 1.2)

```typescript
// Learning and optimization systems
interface AdaptiveIntelligence {
  // Memory management
  memory: {
    store: MemoryStorage;
    manager: MemoryManager;
    knowledgeSharing: KnowledgeSharing;
  };

  // Analytics and insights
  analytics: {
    performanceTracker: PerformanceTracker;
    trendAnalyzer: TrendAnalyzer;
    analyticsStore: AnalyticsStore;
  };

  // Intelligent routing
  routing: {
    router: IntelligentRouter;
    taskClassifier: TaskClassifier;
  };

  // Response caching
  cache: {
    responseCache: ResponseCache;
    semanticMatcher: SemanticMatcher;
  };

  // A/B testing
  experiments: {
    manager: ExperimentManager;
    variantSelector: VariantSelector;
    resultsAnalyzer: ResultsAnalyzer;
  };

  // Confidence scoring
  confidence: {
    scorer: ConfidenceScorer;
    signalCollector: SignalCollector;
    calibration: CalibrationEngine;
  };

  // Context management
  context: {
    windowManager: ContextWindowManager;
    deduplication: Deduplication;
    prioritization: Prioritization;
    threading: Threading;
  };

  // Escalation management
  escalation: {
    manager: EscalationManager;
    triggers: EscalationTriggers;
  };

  // Team optimization
  teams: {
    outcomeTracker: OutcomeTracker;
    weightAdapter: WeightAdapter;
  };
}
```

### HTTP Registry Server

```typescript
// REST API for remote artifact management
class HTTPRegistryServer {
  // Express-based HTTP server
  // OpenAPI/Swagger documentation
  // JWT authentication
  // Rate limiting
  // CORS support
  // Compression (gzip, brotli)
  // Security headers (Helmet)

  routes: {
    // Authentication
    'POST /auth/register': RegisterHandler;
    'POST /auth/login': LoginHandler;
    'POST /auth/refresh': RefreshTokenHandler;
    'POST /auth/logout': LogoutHandler;

    // Artifacts
    'GET /artifacts': ListArtifactsHandler;
    'GET /artifacts/:name': GetArtifactHandler;
    'POST /artifacts': PublishArtifactHandler;
    'PUT /artifacts/:name': UpdateArtifactHandler;
    'DELETE /artifacts/:name': DeleteArtifactHandler;

    // Versions
    'GET /artifacts/:name/versions': ListVersionsHandler;
    'GET /artifacts/:name/versions/:version': GetVersionHandler;

    // Search
    'GET /search': SearchHandler;
    'GET /search/suggestions': SuggestionsHandler;

    // Metrics & Health
    'GET /metrics': MetricsHandler;
    'GET /health': HealthCheckHandler;
    'GET /profiler': ProfilerHandler;
  };
}
```

### CLI Tools

```typescript
// Command-line interface for PCL development
const cli = {
  // Compilation
  'pcl build': 'Compile PCL to JavaScript/TypeScript',
  'pcl watch': 'Watch mode for development',

  // Execution
  'pcl run': 'Execute a PCL program',
  'pcl repl': 'Interactive REPL',

  // Skills management
  'pcl skills list': 'List installed skills',
  'pcl skills search': 'Search skill registry',
  'pcl skills install': 'Install a skill',
  'pcl skills create': 'Create a new skill',
  'pcl skills publish': 'Publish to registry',
  'pcl skills validate': 'Validate skill format',

  // Registry
  'pcl registry export': 'Export registry',
  'pcl registry import': 'Import registry',
  'pcl registry search': 'Search remote registry',

  // Initialization
  'pcl init': 'Initialize PCL project',
  'pcl completion': 'Shell completion scripts',

  // Language server
  'pcl lsp': 'Start language server',

  // MCP server
  'pcl mcp': 'Start MCP server',

  // HTTP server
  'pcl serve': 'Start HTTP registry server',
};
```

## PCL Language Examples

### Basic Persona Declaration

```pcl
persona TYPESCRIPT_EXPERT {
  description: "Expert in TypeScript development"
  skills: [
    "typescript-advanced",
    "type-system-design",
    "compiler-api",
    "testing-frameworks"
  ]
  provider: "anthropic:claude-3-5-sonnet"
  temperature: 0.7
  maxTokens: 4096
}
```

### Team Composition

```pcl
team CODE_REVIEW_TEAM {
  description: "Comprehensive code review team"
  personas: [
    TYPESCRIPT_EXPERT,
    SECURITY_EXPERT,
    PERFORMANCE_EXPERT
  ]
  mergeMode: "consensus"
  weights: {
    TYPESCRIPT_EXPERT: 0.5,
    SECURITY_EXPERT: 0.3,
    PERFORMANCE_EXPERT: 0.2
  }
}
```

### Workflow Orchestration

```pcl
workflow CODE_REVIEW_WORKFLOW {
  description: "Automated code review process"

  step ANALYZE {
    persona: TYPESCRIPT_EXPERT
    input: file("src/components/Button.tsx")
    output: "analysis"
  }

  step SECURITY_CHECK {
    persona: SECURITY_EXPERT
    input: $analysis
    output: "security_report"
  }

  step FINAL_REVIEW {
    team: CODE_REVIEW_TEAM
    input: {
      analysis: $analysis,
      security: $security_report
    }
    output: "final_verdict"
  }
}
```

### Skill Declaration

```pcl
skill RUST_EXPERT {
  name: "rust-expert"
  version: "1.0.0"
  category: "languages"
  description: "Expert in Rust programming"

  capabilities: [
    "memory-safety",
    "concurrency",
    "zero-cost-abstractions",
    "trait-system"
  ]

  tools: ["Read", "Write", "Execute", "Debug"]
}
```

## Anti-Patterns

### ❌ Global State

```typescript
// BAD
let currentPersona: Persona | null = null;

// GOOD
class Parser {
  private currentPersona: Persona | null = null;
}
```

### ❌ Throwing Exceptions

```typescript
// BAD
function parse(source: string): AST {
  throw new Error('Parse failed');
}

// GOOD
function parse(source: string): Result<AST, Error[]> {
  const errors: Error[] = [];
  if (errors.length > 0) {
    return { ok: false, errors };
  }
  return { ok: true, value: ast };
}
```

### ❌ Mutable AST

```typescript
// BAD
function transform(node: PersonaDeclaration) {
  node.skills.push(newSkill);
}

// GOOD
function transform(node: PersonaDeclaration): PersonaDeclaration {
  return {
    ...node,
    skills: [...node.skills, newSkill],
  };
}
```

### ❌ Missing Type Safety

```typescript
// BAD
function processNode(node: any) {
  if (node.type === 'PersonaDecl') {
    // Typo - should be PersonaDeclaration
  }
}

// GOOD
type ASTNode =
  | { type: 'PersonaDeclaration' /* ... */ }
  | { type: 'SkillDeclaration' /* ... */ };

function processNode(node: ASTNode) {
  switch (
    node.type
    // TypeScript enforces correct types
  ) {
  }
}
```

## Performance Optimization

### Caching Strategies

```typescript
// Memoize expensive computations
const typeCache = new Map<ASTNode, Type>();

function inferType(node: ASTNode): Type {
  if (typeCache.has(node)) {
    return typeCache.get(node)!;
  }
  const type = computeType(node);
  typeCache.set(node, type);
  return type;
}
```

### String Interning

```typescript
// Deduplicate identical strings
class StringPool {
  private pool = new Map<string, string>();

  intern(str: string): string {
    if (this.pool.has(str)) {
      return this.pool.get(str)!;
    }
    this.pool.set(str, str);
    return str;
  }
}
```

### Stream Processing

```typescript
// Process large files in chunks
async function* parseStream(stream: ReadableStream): AsyncGenerator<ASTNode> {
  const lexer = new StreamingLexer(stream);
  const parser = new IncrementalParser(lexer);

  for await (const node of parser.parseNodes()) {
    yield node;
  }
}
```

## Reference Documentation

Detailed material lives alongside this skill and is read on demand:

- [Core Competencies](references/CORE_CONCEPTS.md) — Language Design & Specification, Compiler Architecture, Runtime Systems, Language Server Protocol (LSP), Model Context Protocol (MCP), Standard Library (stdlib), Registry & Package Management, Observability & Telemetry
- [Best Practices](references/BEST_PRACTICES.md) — Compiler Development, Runtime Design, Language Design, Testing Strategy

## Resources

### Official Documentation

- **GitHub Repository**: <https://github.com/personamanagmentlayer/pcl>
- **Language Specification**: [docs/reference/LANGUAGE.md](../../../docs/reference/LANGUAGE.md)
- **Compiler Design**: [docs/HOW_PCL_WORKS.md](../../../docs/HOW_PCL_WORKS.md)
- **Runtime Systems**: [docs/SKILL_RUNTIME.md](../../../docs/SKILL_RUNTIME.md)
- **LSP Implementation**: [docs/guides/VSCODE-SETUP.md](../../../docs/guides/VSCODE-SETUP.md)

### Learning Resources

- **Crafting Interpreters**: <https://craftinginterpreters.com/>
- **Modern Compiler Implementation**: <https://www.cs.princeton.edu/~appel/modern/>
- **TypeScript Deep Dive**: <https://basarat.gitbook.io/typescript/>
- **Language Server Protocol**: <https://microsoft.github.io/language-server-protocol/>
- **Model Context Protocol**: <https://modelcontextprotocol.io/>

### Standards & Specifications

- **ISO 5218**: Gender Representation
- **ISO 639-1**: Language Codes
- **IEEE 2410**: Biometric Open Protocol
- **W3C**: Web Standards
- **OpenTelemetry**: Observability Standards
- **OpenAPI**: API Specification

### Community

- **Discord**: PCL Developer Community
- **Stack Overflow**: Tag `persona-control-language`
- **GitHub Discussions**: Q&A and feature requests
- **Newsletter**: Monthly PCL updates

---

## Version History

- **v1.0.0** (2026-01-31): Initial PCL Expert skill
  - Comprehensive compiler architecture coverage
  - Runtime systems and execution engine
  - LSP and MCP integration
  - Adaptive intelligence features
  - HTTP registry server
  - CLI tooling
  - Standard library overview
  - Best practices and anti-patterns
  - Performance optimization techniques

## Maintenance

**Status**: ✅ Active
**Last Updated**: 2026-01-31
**Maintainer**: PCL Core Team
**License**: MIT

© personamanagmentlayer · Apache-2.0 · personamanagmentlayer/pcl

Similar skills

All skills for Programming languages →

From the same set104

The whole set →
codeql-expert The codeql-expert skill guides CodeQL database setup, custom query writing, and vulnerability scans. Use it for SAST tasks, taint tracking, and GitHub security workflows. CX Codex +1 174installs skill-creator-expert skill-creator-expert guides you through designing, writing and checking PCL skills, from domain analysis to a frontmatter template and a quality checklist. CX Codex +1 173installs django-expert django-expert guides full-stack Django development covering ORM models, views, forms, authentication, and Django REST Framework APIs. CX Codex +1 172installs graphql-expert graphql-expert is a Claude Code skill for GraphQL schema design, resolvers, and subscriptions, with guidance on Apollo federation and N+1 queries. CX Codex +1 169installs data-mesh-expert data-mesh-expert walks the agent through data mesh work: domains own their data, products ship with contracts, governance is federated and the platform serves itself. CX Codex +1 168installs swift-expert swift-expert guides an agent through Swift work for iOS and macOS, from SwiftUI screens to async code. Use it when a task involves Combine or modern Swift features. CX Codex +1 163installs linkerd-expert linkerd-expert — a Linkerd skill for Kubernetes work: the agent installs the mesh, injects the proxy, pulls linkerd viz metrics and writes access policies. CX Codex +1 162installs sql-expert sql-expert — a skill for expert SQL work: schema design, efficient queries, index optimization, and administration across PostgreSQL, MySQL, and SQL Server. CX Codex +1 1installs

Project sponsors

Companies that keep this analytics open