How is this different from just adding instructions to my system prompt?

Standard LLM prompts are often 'forgotten' as context windows grow, but this skill creates a structured reasoning layer that forces the agent to check your specific architectural rules before it begins writing code.

Which AI agents or IDEs are compatible with this skill?

The skill is optimized for CLI and IDE-based environments like Claude Code and Cursor that support persistent file-based memory and local skill directories.

How do I teach the agent new patterns or project-specific 'gotchas'?

You can use the `/learn-this` command after correcting the agent, or manually define patterns using `/new-rule` to ensure the agent never repeats the same mistake twice.

Can I use different rule sets for different projects, or is it one-size-fits-all?

Yes, it uses a dual-layer storage system that allows you to maintain global engineering standards across all projects while applying unique rules to specific repositories.

Are there any specific technical requirements or file structures needed to make this work?

The skill requires a specific directory structure under `~/.claude/` and utilizes Markdown files to organize domain-specific rules for easy retrieval and scanning.

Works with the AI tools you already use

+22 more

+18 agents

think like me

Enforce custom engineering rules and capture hard-won technical patterns into an active reasoning layer.

Free

Security scanned

think like me

Example session with this skill installed

/new-rule for all React components: always use functional components with memo wrapper if they receive more than 3 props to prevent unnecessary re-renders.

Read your context and instructions
Compiled the think like me

I have drafted a new rule for the

ui domain. Please review the details below before I save it to your curated engineering rules.

Proposed Rule: Component Memoization

When: Creating or refactoring React functional components that accept multiple props.
Do: Wrap the component in React.memo() and use functional component syntax.
Don't: Use class components or raw functional components for prop-heavy renders.

Why: Prevents performance degradation from unnecessary re-renders in complex UI trees where props are frequently passed down.

Storage Details:

Rule File: ~/.claude/skills/think-like-me/rules/ui.md
Memory Path: ~/.claude/projects/-Users-dev-project/memory/feedback_component_memoization.md

Next steps

Reply with yes to commit this rule to your global UI library and project memory.
Reply with cross-project to flag this as a universal rule for all future React projects.
Reply with any edits if you want to refine the triggers or reasoning.

Connects securely to your tools. The creator never sees your data.

About this skill

Generic LLM responses often ignore the hard-won engineering lessons specific to your stack, such as mobile background task limitations or proprietary auth flows. This skill creates an active reasoning layer that forces the agent to consult your personal, curated rules before generating code. It bridges the gap between passive project memory and active architectural enforcement.

What it does

Active Reasoning enforces specific engineering patterns across mobile, backend, and UI domains before drafting code.
Rule Capture converts developer corrections into permanent rules using /learn-this or automated detection.
Contextual Application scans project metadata to apply domain-specific rules based on task keywords.
Dual-Layer Storage synchronizes rules between global skill files and project-specific memory for deep context.
Conflict Resolution identifies and flags contradictory rules to ensure architectural consistency.

How it works

Rule Consultation triggers automatically on any technical task, scanning the relevant domain markdown files for keywords.
Acknowledgment provides a one-line confirmation of which rules are being applied before code is written.
Reactive Learning prompts you to save a rule whenever you correct the agent's output or push back on a pattern.
Manual Creation allows proactive rule-setting using the /new-rule command for specific project constraints.

Frameworks & tools

This skill is designed for environments like Claude Code or Cursor. It manages markdown files within ~/.claude/skills/ and integrates with project-level memory directories.

Why this beats prompting it yourself

Manual prompts are forgotten across sessions and generic system instructions get ignored as context windows grow. This skill implements a structured retrieval and acknowledgment loop that ensures your specific "gotchas" are never bypassed during code generation.

Use cases

Enforcing specific background mode configurations for mobile audio apps.
Preventing the agent from editing auto-generated folders like Expo's ios/ directory.
Standardizing API response shapes across different microservices.
Capturing edge-case fixes that documentation misses but your project requires.

Known limitations

Requires a specific directory structure under ~/.claude/ to function correctly. Rule detection relies on clear domain labeling within the rule files.

How to install

Works the same in every agent - Claude, Cursor, Codex, Copilot and 20+ more.

~30 seconds

1
Download the ZIP
Free skills download straight away. Paid skills unlock right after purchase.
2
Unzip into your skills folder
Every agent reads skills from one folder on your machine. Drop the unzipped folder in there.
3
Ask your agent to use it
Restart the agent if it was already running. It picks the skill up automatically - no config needed.

Skills folder by agent

Click the path to copy it. Create the folder if it does not exist yet.

Reviews

No reviews yet

Be one of the first to try it. Every listed skill passes our trust checks below.

Security scanned

Passed our 8-point scan before listing

Fresh listing

Recently published to Agensi

Free forever

No account required to browse

Trust & safety

Security scanned

Verified clean 2 days ago

Free to download with an account

Needs access to

Jsdelivr

Googleapis

Gstatic

Listed2 days ago

think like me