SENSE-THINK-ACT: The Architecture Pattern That Makes Claude Code Skills Compound in Value

Mar 28, 2026

Problem

I built a marketing skill system on Claude Code for 3 months. Each skill worked well individually. My Reddit monitor skill detected brand mentions. My content drafting skill produced good posts. My publishing skill handled scheduling correctly.

But something was missing. Every session started fresh. Claude had no memory of what worked before. I had to re-explain my brand voice, re-state my audience preferences, and re-teach the patterns I’d already established.

Here’s what a typical session looked like:

User: Draft a tweet about our new feature

Claude: Sure! What's your brand voice?
User: Professional but friendly

Claude: What topics does your audience like?
User: Developer tools, productivity tips

Claude: Any previous tweets I should reference?
User: Check our Twitter history...

This happened every time. The skills were useful, but they didn’t compound. Each session was a reset.

What I Discovered

I searched for why my skills weren’t building on each other. I found a pattern that practitioners were using successfully: separate concerns into three layers.

The insight was clear: “The pattern that works: separate SENSE skills (monitor Reddit, LinkedIn, YouTube for market signals) from ACT skills (draft content, schedule posts, engage) with a THINK layer in between that reasons about what to do.”

The critical piece wasn’t the skills themselves. It was connecting them through persistent brand memory. Without that, each skill session starts from zero.

The Architecture

I restructured my skills into three layers:

+-----------------------------------------------------+
|                    SENSE LAYER                       |
|  +----------+ +----------+ +----------+             |
|  | Reddit   | | LinkedIn | | YouTube  |             |
|  | Monitor  | | Signals  | | Trends   |             |
|  +----+-----+ +----+-----+ +----+-----+             |
|       |            |            |                   |
|       +------------+------------+                   |
|                    |                                |
|            +---------------+                        |
|            |  Raw Signals  |                        |
|            +-------+-------+                        |
+--------------------|--------------------------------+
                     |
                     v
+-----------------------------------------------------+
|                    THINK LAYER                       |
|  +----------------------------------------------+   |
|  |           Persistent Brand Memory            |   |
|  |  * Brand voice guidelines                    |   |
|  |  * Historical content patterns               |   |
|  |  * Audience preferences                      |   |
|  |  * Past performance metrics                  |   |
|  +----------------------------------------------+   |
|                      |                              |
|                      v                              |
|            +------------------+                     |
|            |  Reasoning &     |                     |
|            |  Planning        |                     |
|            +--------+---------+                     |
+---------------------|--------------------------------+
                      |
                      v
+-----------------------------------------------------+
|                     ACT LAYER                        |
|  +----------+ +----------+ +----------+             |
|  | Draft    | | Schedule | | Engage   |             |
|  | Content  | | Posts    | | Replies  |             |
|  +----------+ +----------+ +----------+             |
+-----------------------------------------------------+

Each layer has a distinct responsibility.

SENSE layer: Monitor data sources and collect signals. These skills run frequently, detect changes, and normalize output for downstream processing.

THINK layer: Maintain persistent memory, reason about signals, and generate action plans. This layer is stateful and context-rich.

ACT layer: Execute planned actions. These skills are idempotent and retry-safe.

Why Three Layers?

The separation solves three problems:

Problem 1: Trigger reliability is probabilistic

Skills activate through pattern matching, not deterministic rules. When I combined sensing and acting in one skill, the trigger became ambiguous. “Monitor Reddit and draft content” - which part should activate?

Separating layers makes triggers explicit:

# SENSE skill trigger
"monitor reddit" -> activates reddit-monitor skill

# THINK skill trigger
"plan content" -> activates content-planner skill

# ACT skill trigger
"publish content" -> activates content-publisher skill

Each skill has a clear activation phrase. The THINK layer reduces dependency on probabilistic matching alone.

Problem 2: Memory was session-only

When I ran my content drafting skill, it had no access to previous decisions. I couldn’t reference:

What tone worked best last month
Which topics generated most engagement
What posting times performed best

The THINK layer maintains persistent brand memory that all skills can access.

Problem 3: Debugging was difficult

When a workflow failed, I couldn’t tell which part broke. Did the monitoring fail? Did the planning fail? Did the execution fail?

With layered architecture, I can debug each layer independently.

The Brand Memory Component

This is the component that enables compound value. I implemented it as a JSON file that the THINK layer reads and writes:

interface BrandMemory {
  brandVoice: {
    tone: string[]
    vocabulary: Set&lt;string&gt;
    styleGuidelines: string
  }
  contentHistory: ContentItem[]
  audienceInsights: {
    preferences: Map&lt;string, number&gt;
    engagementPatterns: EngagementMetric[]
  }
  performanceMetrics: {
    topPerformingContent: ContentItem[]
    optimalPostingTimes: TimeSlot[]
  }
}

The actual file structure:

{
  "brandVoice": {
    "tone": ["professional", "helpful", "technical"],
    "avoidWords": ["synergy", "leverage", "disrupt"],
    "styleGuidelines": "Clear, code-first explanations"
  },
  "contentHistory": [
    {
      "date": "2026-03-27",
      "topic": "Claude Code skills",
      "type": "blog",
      "performance": {
        "views": 1500,
        "engagement": 0.08
      }
    }
  ],
  "audienceInsights": {
    "preferredTopics": ["Claude Code", "AI workflows", "Developer tools"],
    "optimalPostTime": "09:00 PST"
  }
}

Now when my ACT skill drafts content, it reads this file first. No re-explanation needed.

SENSE Skill Example

I created a Reddit monitor skill that outputs normalized signals:

---
name: reddit-monitor
description: SENSE skill - Monitors Reddit for brand mentions and market signals
trigger:
  - "monitor reddit"
  - "check reddit signals"
  - "reddit trends"
---

## Purpose
Collect raw signals from Reddit for downstream THINK layer processing.

## Output Format
Output signals in JSON format:

{
  "signals": [
    {
      "source": "r/programming",
      "type": "discussion",
      "content": "...",
      "sentiment": "positive",
      "relevance_score": 0.85
    }
  ]
}

The skill is lightweight. It runs frequently. It doesn’t make decisions - it just collects and normalizes.

THINK Skill Example

The content planner skill reads brand memory and reasons about signals:

---
name: content-planner
description: THINK skill - Reasons about signals and creates content plan
trigger:
  - "plan content"
  - "create content plan"
  - "what should I post"
---

## Brand Memory Access
Read `.claude/memory/brand-memory.json` to access:
- Brand voice guidelines
- Historical content patterns
- Audience preferences

## Process
1. Load brand memory
2. Analyze input signals from SENSE layer
3. Generate content plan with reasoning
4. Output structured action items

## Output Format

{
  "plan": [
    {
      "action": "draft_tweet",
      "topic": "...",
      "reasoning": "...",
      "priority": "high"
    }
  ]
}

This skill is stateful. It updates brand memory after each run. It’s the brain of the system.

ACT Skill Example

The content publisher skill executes the plan:

---
name: content-publisher
description: ACT skill - Executes content creation and publishing
trigger:
  - "publish content"
  - "create post"
  - "draft and publish"
---

## Input
Receives structured plan from THINK layer.

## Actions
1. Draft content following brand guidelines
2. Review against brand memory constraints
3. Schedule for optimal time
4. Record in content history

## Idempotency
Check content history before creating to avoid duplicates.

This skill is execution-focused. It’s retry-safe and idempotent.

Comparison: Before and After

Aspect	Monolithic Skill	SENSE-THINK-ACT
Memory	Session-only	Persistent across sessions
Trigger reliability	High dependency on probabilistic matching	Reduced dependency through explicit layering
Value accumulation	None - resets each session	Compounds with every interaction
Debuggability	Difficult - can’t isolate failures	Layer-by-layer debugging
Reusability	Low - skills are coupled	High - skills are modular

Implementation Considerations

I learned some practical lessons:

Trigger design: Use explicit layer keywords in skill descriptions. “SENSE skill - monitors Reddit” makes the trigger clear. Claude Code’s pattern matching works better with explicit hints.

Memory storage: I started with file-based JSON storage. For larger systems, consider SQLite or PostgreSQL. The key is that memory persists between sessions.

Error handling: Each layer should be independently retryable. If the ACT layer fails, the THINK layer’s plan is still valid. Retry the ACT skill without re-planning.

Testing: Unit test each skill. Integration test the chain. I verify that:

SENSE skills output valid signal format
THINK skills read/write memory correctly
ACT skills execute plans without duplicates

How a Session Works Now

With the three-layer architecture, a session looks different:

User: Draft a tweet about our new feature

Claude: [THINK layer activated]
Loaded brand memory:
- Tone: professional, helpful, technical
- Audience prefers: Claude Code, AI workflows
- Optimal time: 09:00 PST

[SENSE layer signals]
- Reddit thread about Claude Code skills (high relevance)
- LinkedIn post about AI workflows trending

[Plan generated]
1. Draft tweet about Claude Code skills feature
2. Schedule for 09:00 PST tomorrow
3. Reference Reddit thread for engagement hook

[ACT layer executing]
Tweet drafted. Ready for review.

No re-explanation. Context loaded automatically. Decisions informed by accumulated knowledge.

Summary

The SENSE-THINK-ACT architecture transforms Claude Code skills from isolated, disposable tools into a compound system. The key insight isn’t about building better individual skills - it’s about connecting them through persistent memory so each session builds on accumulated context.

Without this architecture, every skill invocation starts from zero. With it, your AI assistant develops institutional knowledge that compounds with every interaction.

The pattern works because it mirrors how humans work: we sense the world, think about what we’ve learned (drawing on memory), and then act. Give your Claude Code skills the same architecture, and they’ll deliver the same compound returns.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 Reddit: Skill Architecture Discussion
👨‍💻 Claude Code Skills Documentation
👨‍💻 MCP Server Architecture

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!