memory-alignment-check

Validate completed Story implementation footprints against long-term memory entries.

157|28|Updated Feb 7, 2026
One-click install
npx skills add https://github.com/Fr-e-d/GAAI-framework --skill memory-alignment-check-fr-e-d
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: memory-alignment-check
Source: https://github.com/Fr-e-d/GAAI-framework/tree/main/.gaai/core/skills/cross/memory-alignment-check
Command: npx skills add https://github.com/Fr-e-d/GAAI-framework --skill memory-alignment-check-fr-e-d

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill ensures that the AI's long-term memory (decisions, patterns, project context) remains consistent with the actual code implementation after a task is completed, preventing drift and maintaining a reliable knowledge base.

Core Features & Use Cases

  • Post-QA Verification: Runs automatically after a Story's Quality Assurance (QA) passes.
  • Footprint Analysis: Compares the specific changes made during implementation against relevant memory entries.
  • Consistency Reporting: Identifies confirmed memory entries, highlights contradictions, and flags new knowledge candidates not yet in memory.
  • Use Case: After a new feature is implemented and passes QA, this skill verifies that the new code aligns with established architectural patterns and decisions stored in memory, reporting any discrepancies or new patterns that should be added to memory.

Quick Start

Run the memory-alignment-check skill after QA has passed for story E01S01.

Frequently Asked Questions about memory-alignment-check

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

FAQPage Schema
How do I verify code implementation aligns with existing project memory?

Code verification against project memory involves analyzing modified files, new modules, and applied patterns against indexed long-term entries to report confirmations, contradictions, and new knowledge candidates.

What is memory alignment checking in software engineering?

Memory alignment checking is a post-QA verification process that ensures a completed story's implementation footprint matches established architectural decisions and patterns stored in long-term memory, preventing knowledge base drift.

How do I check for contradictions between new code and established technical decisions?

Check for contradictions by running a memory alignment verification after QA passes, which compares specific implementation changes against relevant memory entries using scope tags to highlight discrepancies and new patterns.

When do I need to run a memory alignment check?

You need to run a memory alignment check after a story's Quality Assurance passes, ensuring the newly implemented feature footprint is validated against existing indexed memory before finalizing the task.

Does memory alignment checking work with selective memory entries?

Yes, memory alignment checking operates on specific artefact reports and selective memory entries based on scope tags, allowing targeted verification of relevant code patterns and technical decisions.

What are the limitations of automated memory consistency reporting?

Automated memory consistency reporting relies on existing indexed memory entries and accurate scope tags to identify confirmations and contradictions, meaning unindexed or improperly tagged technical decisions may be missed during footprint analysis.