neat

Reconcile project documentation and agent memory against the current codebase.

5|Updated Jun 5, 2026
One-click install
npx skills add https://github.com/VincentJiang06/skills --skill neat
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: neat
Source: https://github.com/VincentJiang06/skills/tree/main/skills/neat
Command: npx skills add https://github.com/VincentJiang06/skills --skill neat

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

After development sessions, project documentation, agent memory, and AI instruction files often fall out of sync with the latest code, leading to stale information, duplicated content, and missing context that slows down new contributors and future AI development sessions.

Core Features & Use Cases

  • Deterministic anti-bloat linter: Enforces hard size limits for memory indexes and project instruction files, catches broken links, relative time references, and memory/docs size inversions with machine-checkable rules.
  • Knowledge graduation mechanism: Promotes stable, reusable knowledge from temporary agent memory to permanent project documentation to prevent memory bloat.
  • Cross-platform support: Works with Claude Code, OpenAI Codex, OpenCode, and OpenClaw, with platform-specific path references for memory and configuration files.
  • Use case: After finishing a development milestone, use this skill to reconcile all project knowledge artifacts against the current codebase, so no critical context is lost or outdated.

Quick Start

Use the neat skill to reconcile all project documentation and cross-session agent memory against the current codebase at the end of this development session.

Frequently Asked Questions about neat

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I reconcile project documentation and agent memory against the current codebase after a development session?

You can reconcile project documentation and agent memory by running an end-of-session cleanup skill that cross-references docs, memory indexes, and CLAUDE.md/AGENTS.md files against the codebase. It eliminates stale, duplicated, or misaligned knowledge artifacts to ensure all layers reflect the latest code changes.

What is knowledge rot in AI-assisted development and how do I prevent it?

Knowledge rot occurs when project documentation, agent memory, and AI instruction files fall out of sync with the latest code, leaving stale context. You prevent knowledge rot by enforcing deterministic validation rules, size ceilings, and promoting stable memory content to permanent documentation at session end.

Does this documentation sync workflow support OpenAI Codex and OpenCode alongside Claude Code?

Yes, this knowledge cleanup workflow supports Claude Code, OpenAI Codex, OpenCode, and OpenClaw. It applies platform-specific path references to reconcile memory indexes, project documentation, and configuration files across all these cross-platform development environments.

How do I enforce size limits and detect broken links in agent memory and instruction files?

You enforce size limits and detect broken links using a deterministic anti-bloat linter. It applies machine-checkable rules to catch memory/docs size inversions, broken index links, and relative time references, ensuring project instruction files remain within hard size ceilings.

What is the best way to promote temporary agent memory to permanent project documentation?

The best way to promote temporary agent memory is through a knowledge graduation mechanism. It identifies stable, reusable context from cross-session agent memory and moves it to permanent project documentation, preventing memory bloat while preserving critical development context for future milestones.

When should I run an end-of-session knowledge base cleanup for my software project?

You should run a knowledge base cleanup at the end of development sessions or after reaching a development milestone. This ensures that all project knowledge artifacts, including docs, memory indexes, and instruction files, are reconciled with the current codebase before context is lost or becomes outdated.