shalin-rahman/skills/agentic-architecture
skills/agentic-architecture/SKILL.md
# Skill: Agentic Architecture & ReAct Patterns # Usage: Use when designing autonomous agents, tool-calling pipelines, or LLM-driven workflows. ## 🤖 Core Agent Architecture - **Perception/Input**: The mechanism by which the agent receives state (Prompts, Vision, API payloads). - **Cognition/Brain**: The LLM determining the next action based on its System Prompt and context. - **Action/Tools**: The deterministic execution of commands (API calls, file writes, code execution). - **Memory**: - *
$ install --global
skillsauthnpx skillsauth add shalin-rahman/Synapticity skills/agentic-architectureInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
Security Scan Results
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
3
Scanners Passed
9
Scanners in report
Clean
TrivyContainer and dependency vulnerability scanner
95%
Clean
SemgrepStatic code analysis for vulnerabilities
95%
Clean
mcp-scan (Snyk)Model Context Protocol security validation
95%
Skipped
Snyk (dep)Open source security scanning
50%
Skipped
Socket.devSupply chain security analysis
50%
Skipped
VirusTotalMulti-engine malware detection
50%
Skipped
CrowdStrikeAdvanced threat intelligence
50%
Skipped
OSV-ScannerOpen Source Vulnerability database check
50%
Skipped
OWASP Dep-Check
50%
Last scanned: Apr 23, 2026, 12:40 AM174.0s1 file scanned
SKILL.md
Skill: Agentic Architecture & ReAct Patterns
Usage: Use when designing autonomous agents, tool-calling pipelines, or LLM-driven workflows.
🤖 Core Agent Architecture
- Perception/Input: The mechanism by which the agent receives state (Prompts, Vision, API payloads).
- Cognition/Brain: The LLM determining the next action based on its System Prompt and context.
- Action/Tools: The deterministic execution of commands (API calls, file writes, code execution).
- Memory:
- Short-Term: The immediate conversation/context window.
- Long-Term: Vector databases or persistent stores for past interactions.
🔄 The ReAct Paradigm (Reason + Act)
Build agents that interleave reasoning with taking actions.
- Thought: The LLM explicitly reasons about what it needs to do next. (e.g., "I need to find the user's ID to fetch their orders.")
- Action: The LLM outputs a structured command to invoke a tool. (e.g.,
CallTool: SearchUser(name="Alice")) - Observation: The system executes the tool and returns the deterministic result to the LLM.
- Repeat: The LLM repeats this cycle until the overarching goal is achieved.
🛠️ Tool Calling (Function Calling)
- Strict Schemas: Define tools using strict JSON schemas (OpenAPI style) to ensure the LLM understands expected inputs.
- Atomic Tools: Tools should do exactly one thing well. Avoid mega-tools with overly complex parameters.
- Error Feedback: If a tool fails (e.g., 404, type error), feed the explicit error message back into the LLM as an Observation so it can self-correct.
🚫 Anti-Patterns in Agent Design
- Assuming Determinism: Never assume the LLM will output the exact same JSON format twice without strict enforcement (like JSON grammar parsing).
- Infinite Loops: Always implement a
max_iterationsor budget limit on the ReAct loop to prevent the agent from getting stuck. - Dangerous Auto-Run: Never allow an agent to execute destructive actions (DELETE, DROP, execute arbitrary shell code) without human-in-the-loop approval or strict sandboxing.
Related Skills
shalin-rahman/skills/zero-defect-engineering
tools
VerifiedTrustedCommunity
# Skill: Zero-Defect Software Engineering # Focus: Writing immortal, self-documenting, and resilient source code. ## Playbook Strategy: 1. **SOLID Foundations**: - **Single Responsibility**: Every class/function does ONE thing perfectly. - **Open/Closed**: Design for extension without modification. 2. **DRY (Don't Repeat Yourself)**: If logic appears twice, abstract it into a utility or base class. 3. **Defensive Programming**: - Validate every input. - Handle every exception specif
1SKILL.mdUpdated Apr 22, 2026
shalin-rahman/skills/typescript-clean
development
VerifiedTrustedCommunity
# Skill: TypeScript Clean Code (Staff Engineer) # Usage: Use for any TypeScript-based project to ensure enterprise-grade type safety and readability. ## Core Rules: - **Strict Typing:** Never use `any`. Use `unknown` with type guards if the type is truly uncertain. - **Interfaces vs Types:** Use `interface` for public APIs (extendability) and `type` for unions, intersections, and primitives. - **Functional Patterns:** Prioritize immutability. Use `readonly` for arrays and objects where possible
1SKILL.mdUpdated Apr 22, 2026
shalin-rahman/skills/testing-strategies
development
VerifiedTrustedCommunity
# Skill: Advanced Testing Strategies (TDD / BDD) # Usage: Use to enforce high code quality, prevent regressions, and ensure requirements are met implicitly. ## 🧪 The Testing Pyramid - **Unit Tests (70%)**: Fast, isolated tests for individual functions and classes. Mock all external dependencies. - **Integration Tests (20%)**: Test the interaction between several units or external systems (e.g., Database, APIs). - **End-to-End (E2E) Tests (10%)**: Slow, brittle tests that verify the system as a
1SKILL.mdUpdated Apr 22, 2026
shalin-rahman/skills/technical-writing-standards
development
VerifiedTrustedCommunity
# Skill: Technical Hand-off & Clarity # Focus: Professional documentation for human and machine consumption. ## Playbook Strategy: 1. **The "ReadMe First" Rule**: Use structured, hierarchical markdown. High-level summary first, deep-dive implementation second. 2. **Contextual Grounding**: Explain the "Why" and the "How" for every project. 3. **Semantic Clarity**: Use industry-standard terminology. Avoid jargon where simple language suffices. 4. **Machine-Readable Annotations**: Include clear co
1SKILL.mdUpdated Apr 22, 2026