skills.rest
phanijapps
phanijappsCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

engram-plan

Sequence Rust core, TypeScript bindings, and storage adapters for agentic memory roadmaps.

Updated Jun 29, 2026
Search Tags:#typescript#architecture#rust#software-design#engram#agentic-memory
One-click install
npx skills add https://github.com/phanijapps/engram --skill engram-plan
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: engram-plan
Source: https://github.com/phanijapps/engram/tree/main/.claude/skills/engram-plan
Command: npx skills add https://github.com/phanijapps/engram --skill engram-plan

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill addresses the complexity of designing and implementing agentic memory layers by providing a structured, contract-first planning framework that ensures modularity and technical alignment.

Core Features & Use Cases

  • Implementation Sequencing: Guides the logical build order of Rust-based memory cores, TypeScript bindings, and storage adapters.
  • Contract-Backed Planning: Enforces the use of domain models and ports-and-adapters architecture to prevent tight coupling.
  • Use Case: Use this skill when you need to define the roadmap for a new memory-enabled agent, ensuring that the Rust domain crate, storage adapters, and TypeScript SDK are developed in a testable, vertical-slice-oriented manner.

Quick Start

Use the engram-plan skill to generate a development roadmap for the new SQL storage adapter based on the existing crate map.

Frequently Asked Questions about engram-plan

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

FAQPage Schema
How do I architect an agentic memory system for durable agent context?▼

Architecting an agentic memory system requires structuring an implementation roadmap that sequences Rust core components, TypeScript bindings, and storage adapters using domain-driven design principles and ports-and-adapters patterns for modularity.

What is the best way to sequence Rust and TypeScript bindings for agent memory?▼

Sequencing Rust and TypeScript bindings is best achieved through vertical slice definition, mapping crate dependencies to logically build the Rust memory core and TypeScript SDK in a testable, contract-backed manner.

How does ports-and-adapters architecture apply to storage adapters in Rust?▼

Ports-and-adapters architecture applies to storage adapters by enforcing contract-backed domain models, preventing tight coupling between the Rust domain crate and its storage implementations while maintaining modularity.

Do I need domain-driven design to build a memory-enabled agent roadmap?▼

Domain-driven design is required to build a memory-enabled agent roadmap, ensuring the Rust domain crate, storage adapters, and TypeScript SDK are developed in a testable, vertical-slice-oriented manner.

Can I use this approach to plan a new SQL storage adapter for an existing crate map?▼

You can use this contract-first planning approach to generate a development roadmap for a new SQL storage adapter based on an existing crate map, ensuring testable vertical slices and modular integration.

Related Skills

Explore More Software Engineering Skills→
YukiIto1999YukiIto1999

reverse-engineering-rust-malware

Identify Rust-compiled malware binaries and extract crate dependencies and suspicious patterns.

Community
Advanced
cmetechcmetech

decompose-into-slices

Decompose milestone plans into dependency-ordered vertical slices with GitHub issues export.

Community
Advanced
ndthanhdevndthanhdev
54

hexagonal-inversify-di

Wire Hexagonal architecture ports and adapters with InversifyJS across a monorepo.

Community
Advanced
LuigiAPCPereiraLuigiAPCPereira
1

brainstorming

Guide initial concepts into detailed technical designs through structured questioning.

Community
Intermediate