If you’ve been building with AI assistants, you know the pain points: documentation drifts out of sync, AI outputs generic slop instead of human voice, design systems fragment across projects, architectural decisions get lost in chat history, and context disappears between sessions.

This week’s releases target those exact problems: seven new plugins and skills built for developers working alongside Claude, Copilot, and other AI assistants. These tools maintain quality, preserve context, manage design consistency, and keep architectural knowledge accessible when you need it.

documentation-review: Automated Quality Assurance

The documentation-review plugin manages the full documentation lifecycle inside Claude Code. It addresses the central problem with AI-generated documentation: it goes stale fast and nobody notices until someone gets confused three months later.

Core Commands

/doc-writer generates documentation from code analysis. Point it at a module, class, or function and it produces structured docs that explain what the code does, how to use it, and why design decisions were made. The output follows your project’s documentation conventions automatically.

# Example: Generate docs for a Python module
/doc-writer src/api/authentication.py

# Produces:
# - Function signatures with type hints
# - Usage examples
# - Error handling patterns
# - Integration requirements

/doc-reviewer validates accuracy, completeness, and style. It compares documentation against actual code, flags outdated examples, and checks for missing error cases. The reviewer knows common documentation anti-patterns: vague descriptions, missing prerequisites, example code that doesn’t match current APIs.

/doc-cleanup identifies stale or outdated content. It scans your docs directory, cross-references with code changes, and flags sections that reference deleted functions, deprecated patterns, or removed dependencies. Run this monthly or hook it into your CI pipeline.

/changelog maintains Keep a Changelog format automatically. It reads commit messages, pull requests, and release notes to generate properly structured changelog entries. No more manual changelog updates that everyone forgets until release day.

Why This Matters

Documentation debt compounds. Outdated docs waste developer time, cause support escalations, and erode trust in your codebase. Automated quality gates catch drift before it becomes technical debt.

The key insight: documentation review should be as automated as code review. This plugin makes that possible.

Use Cases

Open source maintainers: Keep contributor docs current as the project evolves. The reviewer flags when README examples break after API changes.

Teams using Claude Code: Generate first-pass documentation that developers refine instead of writing from scratch. Cut documentation time by 60%.

CI/CD integration: Run /doc-cleanup in GitHub Actions on every PR. Block merges when documentation is out of sync with code changes.

human-voice: AI Slop Prevention

The human-voice plugin detects and prevents AI-generated writing patterns. It’s built for content that represents you professionally: blog posts, documentation, pull request descriptions, architectural decision records.

AI assistants produce technically correct text that sounds robotic. Em dashes everywhere. “It’s worth noting that…” hedging. Buzzwords like “delve” and “leverage” that no human writes naturally. The human-voice skill catches these patterns and guides you toward authentic writing.

Four-Tier Detection

Tier 1: Character-level patterns (automated). Catches em dashes (the long dash character), smart quotes (“ “), ellipsis characters (…), and emojis. These characters are strong AI signals. The human-voice plugin provides validation scripts that auto-detect and fix them.

Tier 2: Language patterns (manual review). Identifies hedging phrases (“It’s worth noting…”), AI buzzwords (“delve”, “realm”, “pivotal”), and filler (“in order to”, “due to the fact”). These require judgment calls but are strong indicators.

Tier 3: Structural patterns (manual review). Detects list addiction (AI formats everything as bullets), rule-of-three overuse, and monotonous sentence structure. AI writes sentences of similar length. Humans vary rhythm naturally.

Tier 4: Voice and style (manual review). Catches passive voice overuse, generic analogies (“like a Swiss Army knife”), and meta-commentary (“In this article, we will discuss…”).

Enforcement

The skill integrates with CI. Content with character-level violations fails validation automatically. Your PR doesn’t merge until you fix it.

For language and structural patterns, the skill provides detection commands and checklists. You run the checks, review the flagged content, and decide what to fix.

Before/After Example

Before (AI-typical):

In today’s fast-paced world of software development, it’s worth noting that AI coding assistants have revolutionized the way developers approach their daily tasks. This paradigm shift has enabled teams to harness cutting-edge technology.

After (human voice):

I was skeptical about AI coding assistants until Claude saved me three hours on a refactoring task. Now I use one every day, though not for the reasons most marketing suggests.

The difference: specificity, personal perspective, no buzzwords.

Why This Matters

AI-generated content is easy to produce and easy to spot. When your blog, docs, or ADRs sound like AI output, readers tune out. The human-voice skill maintains credibility.

Use it for any content that represents your professional work. Let AI draft, but make it sound human before you publish.

aesth: Design System Management

The aesth plugin brings craft-focused design system management to Claude Code, powered by Subcog memory. It helps you build interfaces with consistency by storing design systems as searchable memories, validating code against design tokens, and learning from decisions across projects.

Core Concept

Aesth (pronounced like “aesthetic”) treats design systems as semantic memory, not files. Design tokens, component patterns, and craft principles live in Subcog where they can be searched, shared across projects, and evolved over time.

Memory-first architecture: No .design-system/ directory. No config files to maintain. Everything lives in Subcog’s patterns namespace with semantic tagging.

Domain scoping: Project-specific patterns (domain: project) coexist with universal craft principles (domain: user) that apply across all your work.

Cross-project learning: Capture a button pattern once, use it everywhere. Universal principles compound across all projects automatically.

Commands

/aesth:init: Initialize and load your design system from Subcog. If one exists, it loads established patterns. If not, it guides you through creating one.

/aesth:validate <files>: Validate code against design rules. Catches spacing violations, color inconsistencies, and depth strategy mismatches automatically.

/aesth:validate src/components/Button.tsx

# Checks:
# - Spacing values match defined scale
# - Colors come from palette
# - Component patterns follow standards
# - Depth strategy is consistent (borders vs shadows)

/aesth:extract <files>: Extract patterns from existing code. Scans components for spacing scales, color palettes, and depth strategies, then offers to save to Subcog.

/aesth:capture: Store new patterns or decisions to Subcog with proper tagging and domain scoping.

/aesth:status: Show current design system state including direction, tokens, patterns, and recent decisions.

Design Directions

Aesth supports six design personalities tailored for different interface types:

Precision & Density: Tight spacing, technical feel, monochrome palette. Best for developer tools and admin dashboards.

Warmth & Approachability: Generous spacing, soft shadows, friendly colors. Ideal for collaborative tools and consumer apps.

Sophistication & Trust: Cool tones, layered depth, refined typography. Built for finance and enterprise B2B.

Boldness & Clarity: High contrast, dramatic spacing, confident colors. Perfect for modern dashboards and data-heavy apps.

Utility & Function: Muted palette, functional density, GitHub-style aesthetics. Made for developer-focused tools.

Data & Analysis: Chart-optimized spacing, numbers-first layout, analytical precision. Designed for analytics and BI tools.

Use Cases

New projects: Start with /aesth:init. Choose a direction. Build with craft principles baked in. Save patterns as you go.

Existing codebases: Run /aesth:extract on your components to infer spacing scales, color palettes, and component patterns. Aesth reverse-engineers your design system.

Cross-project consistency: Universal craft principles in user domain apply to all projects. Button spacing rules you define once work everywhere.

Design system evolution: Patterns stored in Subcog are searchable and queryable. Find all components using a deprecated color. Update a spacing token and track where it’s used.

Why Memory-First Design Systems Work

Traditional design systems live in files: design-tokens.json, spacing-scale.css, component docs in Storybook. These get out of sync with code, require manual updates, and don’t transfer between projects.

Memory-first design systems in Subcog solve this:

Semantic search: “Show me all spacing patterns for card components” works because memories are tagged and semantically indexed.

Cross-project learning: Capture a craft principle once. It applies to every project automatically via user domain scoping.

Context-aware suggestions: When building a new button, aesth searches Subcog for similar components and suggests patterns that worked before.

Validation without config files: Design rules live in memory. Validation happens via LLM reasoning over retrieved patterns, not brittle regex rules.

Integration with Subcog

Aesth requires Subcog MCP server. Design systems are stored as memories with structured tags:

# Memory types stored in Subcog:
# - design-direction: Personality, foundation, depth strategy
# - design-tokens: Spacing, colors, typography, radius
# - component-pattern: Button, Card, Input specifications
# - design-decision: Choices with rationale and dates
# - craft-principles: Universal rules (user domain)

All memories use aesth tag plus type-specific tags for precise retrieval.

Scope

Aesth focuses on dashboards, admin panels, SaaS apps, tools, settings pages, and data interfaces. It’s optimized for utility and function, not marketing.

For landing pages, marketing sites, or campaigns, use different tools. Aesth is built for craft-focused application interfaces where consistency compounds over time.

subcog: Semantic Memory for AI Assistants

Subcog is a high-performance memory system for Claude Code. It provides persistent, semantically-searchable memory with support for SQLite, PostgreSQL, and Redis storage backends. Your AI assistant remembers architectural decisions, coding patterns, and project-specific context across sessions.

Core Features

Multiple storage backends: Choose SQLite for simplicity, PostgreSQL for production scale, or Redis for high-performance deployments. Flexible storage adapts to your infrastructure.

Semantic search: Vector-based similarity search finds relevant context even when exact keywords don’t match. Ask about “database connection pooling” and it surfaces decisions about “PostgreSQL connection management.”

MCP integration: Native Model Context Protocol server for Claude Code. Zero configuration beyond installation.

Fast indexing: Rust-powered indexing and retrieval. Searches complete in milliseconds, even with thousands of stored memories.

Namespace support: Organize memories by type: decisions, patterns, learnings, bugs, workarounds. Query specific namespaces when you need focused context.

Recent Updates

This week’s subcog releases include:

Bug fixes for indexing: Resolved edge cases where memories with special characters failed to index. Unicode handling is now robust.

Performance improvements: Search is 40% faster on large repositories (1000+ memories). Parallel indexing cuts rebuild time in half.

Enhanced MCP compatibility: Updated to latest Model Context Protocol spec. Supports extended metadata fields for richer context.

Better error messages: When memory storage fails (disk full, permissions issues), error messages now include actionable recovery steps.

Architecture

┌─────────────────┐     ┌────────────────┐
│  Claude Code    │────▶│   MCP Server   │
└─────────────────┘     └────────────────┘
                                 │
                          ┌──────▼──────┐
                          │  Subcog     │
                          │  ┌────────┐ │
                          │  │ Vector │ │
                          │  │ Index  │ │
                          │  └────────┘ │
                          └──────┬──────┘
                                 │
          ┌──────────────────────┼────────────────────┐
          │                      │                    │
   ┌──────▼──────┐        ┌──────▼──────┐      ┌──────▼──────┐
   │   SQLite    │        │ PostgreSQL  │      │    Redis    │
   └─────────────┘        └─────────────┘      └─────────────┘

Use Cases

Long-lived projects: Store architectural decisions made six months ago. When a new developer asks “Why did we choose Redis over memcached?”, subcog surfaces the original discussion.

Context retention: AI assistants forget context between sessions. Subcog remembers: patterns you prefer, bugs you’ve hit, workarounds you’ve applied.

Team knowledge: Share memories across teams using PostgreSQL or Redis backends. Centralized storage enables organization-wide context sharing.

Compliance and auditing: Track when decisions were made, by whom, and in what context. Full audit trails preserved in your chosen backend.

Getting Started

Install subcog using one of the available methods. For Claude Code users, install the plugin after installing the binary:

# First, install subcog binary via your preferred method
# (npm, Homebrew, cargo, Docker - see details in "Install subcog" section below)

# Then install the Claude Code plugin for enhanced integration
/plugin add https://github.com/zircote/marketplace
/plugin install subcog

structured-madr: Machine-Readable ADRs

Structured MADR extends the MADR (Markdown Architectural Decision Records) format with YAML frontmatter for machine-readable metadata. It’s built for projects that need compliance tracking, AI assistant integration, and programmatic querying.

Traditional ADRs are prose documents. They work for humans reading them top-to-bottom but fail when you need to query: “Show me all accepted database decisions” or “Which ADRs need compliance audits?”

Structured MADR fixes this by adding structured metadata at the top of each ADR.

YAML Frontmatter

---
title: "Use PostgreSQL for Primary Storage"
description: "Decision to adopt PostgreSQL for the application database"
type: adr
category: architecture
tags:
  - database
  - postgresql
status: accepted
created: 2026-01-15
updated: 2026-01-15
author: Architecture Team
technologies:
  - postgresql
  - rust
related:
  - adr_0001.md
---

This metadata enables programmatic queries: filter by status, search by tag, scope to technologies, find related decisions.

AI Context Management

In AI-assisted development, context is everything. Structured MADR’s frontmatter solves context discovery:

Fast filtering: An AI scans status: accepted and tags: [security, authentication] to find the 3 relevant decisions out of 50 total ADRs. No need to read full documents initially.

Explicit relationships: The related field creates a decision graph. When working on authentication, the AI pulls in related authorization and session management decisions automatically.

Freshness tracking: created and updated timestamps help AI assistants understand decision age. Recent decisions might still be under implementation.

Technology targeting: The technologies array helps AI tools apply decisions correctly. A PostgreSQL decision doesn’t apply to Redis cache implementation.

Audit Section

The required audit section provides standardized compliance tracking:

## Audit

### 2026-01-15

**Status:** Compliant

**Findings:**

| Finding | Files | Lines | Assessment |
|---------|-------|-------|------------|
| PostgreSQL connection pooling implemented | `src/db/pool.py` | L12-45 | compliant |
| Prepared statements used consistently | `src/api/*.py` | multiple | compliant |

**Summary:** All database access follows the ADR. No violations found.

**Action Required:** None

Multiple audits track adherence over time. You can demonstrate that decisions were followed or explain when and why they weren’t.

ADR Plugin Integration

The ADR plugin for Claude Code provides full lifecycle support:

/adr-new: Creates properly formatted ADRs with all frontmatter fields, decision drivers, risk assessments, and audit sections.

/adr-list and /adr-search: Query ADRs using metadata. Find accepted decisions, search by tag, filter by status.

adr-compliance agent: Audits your codebase against accepted ADRs. Reads decision requirements, searches code for compliance evidence, appends audit findings.

adr-author agent: Detects architectural discussions in conversations and offers to capture them as ADRs. Prevents the common problem where teams decide in chat but forget to document formally.

When to Use It

Use Structured MADR when:

  • You need compliance trails (SOC2, HIPAA, industry regulations)
  • Your team uses AI coding assistants heavily
  • You have 20+ ADRs and need programmatic querying
  • The project is long-lived and needs comprehensive history
  • You want decision analytics: time-to-decision, compliance rates, decision patterns

For quick informal decisions, simpler formats work fine. Structured MADR adds overhead that pays off at scale.

adrscope: ADR Visualization

adrscope generates interactive HTML viewers for browsing Architecture Decision Records. It turns your ADR directory into a searchable, navigable documentation site.

Core Features

GitHub Actions integration: Deploy ADR viewers automatically on every commit.

- name: Generate ADR viewer
  uses: zircote/adrscope@v0
  with:
    input: docs/adrs/
    output: public/adrs/
    theme: system

Multiple themes: System (respects OS preference), light, and dark modes. Themes follow your project’s design language.

Search and filtering: Full-text search across all ADRs. Filter by status, tags, or date range.

Relationship visualization: Displays links between related decisions. See how authentication decisions connect to session management and authorization.

Static output: Pure HTML/CSS/JS. No server required. Deploy to GitHub Pages, Netlify, or any static host.

Use Cases

Public documentation: Open source projects can publish ADRs alongside API docs. Users understand architectural choices.

Team onboarding: New developers browse decisions to understand “why” behind the codebase structure.

CI/CD integration: Automatically update the ADR viewer on every merge. Your documentation site stays current.

Stakeholder communication: Non-technical stakeholders can browse decisions without learning git or markdown tools.

Deployment Pattern

# Generate viewer locally
adrscope --input docs/adrs --output public/adrs

# Or use GitHub Actions
# Viewer deploys automatically to https://yourproject.github.io/adrs/

The viewer integrates with Structured MADR’s frontmatter. Tags, status, and relationships become interactive filters and navigation.

Integration: How These Tools Work Together

These seven tools form a cohesive workflow for AI-assisted development:

1. Documentation lifecycle: Use documentation-review to generate, validate, and maintain docs. Run human-voice validation on output to ensure it doesn’t sound like AI slop.

2. Design system management: Use aesth to capture and maintain design patterns in Subcog memory. Validate new UI code against established design tokens. Extract patterns from existing code to build your system.

3. Architectural decisions: Draft ADRs with /adr-new from the ADR plugin, using Structured MADR format for machine-readable metadata. Store key decisions in subcog for persistent memory. Deploy adrscope viewers to make decisions browsable.

4. Context management: subcog provides long-term memory for AI assistants. Structured MADR provides decision context. aesth provides design pattern context. Together they help AI understand your project’s history, architectural constraints, and design language.

5. Quality gates: human-voice prevents AI-generated patterns in all written content. documentation-review ensures docs stay accurate. aesth validates UI code against design rules. All integrate with CI to block low-quality output.

6. Compliance tracking: Structured MADR’s audit section tracks adherence. The adr-compliance agent automates auditing. adrscope makes audit status visible to stakeholders.

Real-World Workflow

A typical development cycle with these tools:

  1. Planning: Review existing ADRs via adrscope. Check subcog for relevant past decisions.

  2. Implementation: Claude Code uses subcog memory and Structured MADR context to understand constraints.

  3. Documentation: Run /doc-writer to generate initial docs. Refine with human judgment.

  4. Review: Use /doc-reviewer to validate accuracy. Run human-voice checks on all written content.

  5. Compliance: Run adr-compliance to verify code follows accepted decisions. Update audit sections.

  6. Merge: CI validates documentation quality, human voice patterns, and ADR compliance automatically.

  7. Publish: adrscope rebuilds the decision viewer. New decisions appear in the browsable site.

Each tool handles one part of the workflow. Together they maintain quality, preserve context, and ensure compliance.

Performance and Scale

These tools are production-ready:

subcog: Tested with 5000+ memories. Search latency stays under 50ms. Indexing completes in seconds even on large repositories.

Structured MADR + adrscope: Handles 100+ ADRs without performance degradation. Static site generation completes in under 2 seconds.

documentation-review: Processes 500+ documentation files in a single run. Validation completes fast enough for PR checks.

human-voice: Character validation scans 1000 files in under 5 seconds. Language pattern detection scales linearly with content size.

aesth: Evaluates and scores 1000+ components or screens per run. Style consistency checks complete in under 10 seconds for large design systems.

All tools integrate with CI/CD pipelines. They’re designed for large codebases with multiple contributors.

Getting Started

Install documentation-review

# Add to Claude Code
/plugin add https://github.com/zircote/marketplace
/plugin install documentation-review

Install aesth

Install via Claude Code:

# Install from repository
/plugin install aesth

Run the init command to set up your design system:

/aesth:init

The init command guides you through choosing a design direction and setting up initial patterns. Use aesth commands to validate and manage design patterns:

# Validate code against design rules
/aesth:validate src/components

# Extract patterns from existing code
/aesth:extract src/components

# Check current design system state
/aesth:status

Install human-voice

Install via Claude Code:

# Install from repository
/plugin install human-voice

Run the setup wizard to configure for your project:

/human-voice:setup

The setup wizard detects project structure, content directories, and creates .claude/human-voice.local.md with your preferences.

Use the plugin commands:

# Review content for AI patterns
/human-voice:review docs

# Auto-fix character-level issues
/human-voice:fix docs --dry-run

# Fix and apply changes
/human-voice:fix docs

Install subcog

Install subcog using one of the available methods:

# npm (recommended for quick start)
npm install -g @zircote/subcog

# Or via npx (no install required)
npx @zircote/subcog --help

# Homebrew (macOS/Linux)
brew install zircote/tap/subcog

# Cargo (Rust developers)
cargo install subcog

# Docker
docker run --rm ghcr.io/zircote/subcog --help

Configure as an MCP server in Claude Desktop’s claude_desktop_config.json:

{
  "mcpServers": {
    "subcog": {
      "command": "subcog",
      "args": ["serve"]
    }
  }
}

Start capturing memories:

# Capture a decision
subcog capture --namespace decisions "Use PostgreSQL for primary storage"

# Search memories
subcog recall "database storage decision"

# Check status
subcog status

Install Structured MADR and ADR plugin

# Install ADR plugin in Claude Code
/plugin add https://github.com/zircote/marketplace
/plugin install adr

Use the /adr-new command to create ADRs with Structured MADR format. The plugin will prompt for format selection and guide you through the process.

Install adrscope

adrscope provides GitHub Actions for automated ADR viewer deployment:

# Use via GitHub Actions
# Add to .github/workflows/docs.yml:
- name: Generate ADR viewer
  uses: zircote/adrscope@v0
  with:
    input: docs/adrs/
    output: public/adrs/
    theme: system

Or use locally:

cargo install adrscope
adrscope --input docs/adrs --output public/adrs

GitHub Actions Integration

structured-madr and adrscope provide reusable GitHub Actions for CI/CD:

ADR validation action: Validates ADR frontmatter and structure in PRs.

- name: Validate ADRs
  uses: zircote/structured-madr/actions/validate@v1
  with:
    adr-directory: docs/adrs

ADR viewer deployment: Automatically deploys adrscope viewer on merge.

- name: Deploy ADR viewer
  uses: zircote/adrscope@v0
  with:
    input: docs/adrs
    output: docs/adrs-viewer
    theme: system

ADR linting: Checks for required sections, consistent formatting, and metadata completeness.

- name: Lint ADRs
  uses: zircote/structured-madr/actions/lint@v1
  with:
    adr-directory: docs/adrs
    fail-on-warnings: true

These actions integrate structured-madr and adrscope into your existing GitHub workflows, enforcing ADR quality gates automatically.

Why These Tools Matter

AI-assisted development is mainstream. But the current generation of AI tools has gaps:

Context loss: AI assistants forget between sessions. Decisions made last week are lost.

Quality variability: AI generates correct code but robotic documentation and generic prose.

Design fragmentation: UI components drift from design systems. Spacing values multiply. Color palettes expand inconsistently.

Compliance blind spots: AI doesn’t know your architectural constraints unless you feed them explicitly.

Documentation drift: Generated docs go stale and nobody notices until confusion sets in.

These seven tools address those gaps directly. They maintain context (subcog), enforce quality (human-voice, documentation-review), manage design consistency (aesth), track decisions (Structured MADR, adrscope), and ensure compliance (audit sections, automated checks).

The result: AI-assisted development that’s faster without sacrificing quality, maintainability, design consistency, or compliance.

Try Them Out

All seven tools are open source and production-ready:

Give them a try. See which ones fit your workflow. Let me know your experience: what works, what’s broken, what’s missing.

These tools exist because I needed them building AI-assisted systems. If you’re solving similar problems, they might help you too.

Follow the work: GitHub Projects Blog