skills.rest
lushly-dev
lushly-devOFFICIAL
Explore all skills by this author →
GitHub

botcore-principles

Clarify botcore design principles for architecture, memory scoping, and secure interactions.

1|Updated Feb 22, 2026
Search Tags:#architecture#security#design-principles#composability#memory-scope#botcore#explicit-registration
One-click install
npx skills add https://github.com/lushly-dev/botcore --skill botcore-principles
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: botcore-principles
Source: https://github.com/lushly-dev/botcore/tree/main/.claude/skills/botcore-principles
Command: npx skills add https://github.com/lushly-dev/botcore --skill botcore-principles

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Botcore design principles codify the fundamental rules that guide architecting modular, secure, and extensible agent tooling, preventing drift and inconsistencies across projects.

Core Features & Use Cases

  • CommandResult Everywhere: standardizes outcomes as structured data to enable reliable reasoning and auditing.
  • Opt-In Composability: allows projects to grow through independent layers without forcing dependencies.
  • Connectors as Capability Boundaries: enforces external access via connectors, providing a clear security contract.
  • Constrained Agency: limits what agents can do, improving safety and governance.
  • Meta-Tool Pattern: reduces token load by exposing a compact, discoverable tool surface.
  • Protocol Over Inheritance: promotes decoupled plugin contracts and easier testing.
  • Scoped Memory: enforces memory access boundaries for isolation and predictable sharing.
  • Explicit Registration: requires explicit surface area declarations for transparency.
  • Defense in Depth: layers security controls to reduce risk.
  • Don’t Rebuild the Runtime: builds above the runtime without duplicating capabilities.

Quick Start

Describe a new feature for botcore following the principles outlined here.

Frequently Asked Questions about botcore-principles

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

FAQPage Schema
What are the core design principles for building modular agent infrastructure?▼

Botcore design principles guide modular agent architecture by enforcing opt-in composability, connector boundaries for external access, and explicit registration. This prevents drift and inconsistencies across projects by codifying fundamental rules for secure, extensible tooling.

How do I enforce security boundaries and constrained agency in agent architecture?▼

Enforce security boundaries by treating connectors as capability contracts, applying scoped memory for isolation, and implementing defense in depth. This limits agent actions through constrained agency, improving safety and governance across infrastructure.

How does the CommandResult pattern standardize agent reasoning and auditing?▼

The CommandResult pattern standardizes outcomes as structured data to enable reliable reasoning and auditing across agent infrastructure. This ensures consistent processing of tool results without relying on unstructured text formats.

When should I use protocol over inheritance for plugin contracts in agent systems?▼

Use protocol over inheritance for plugin contracts when you need decoupled architectures and easier testing. This design principle promotes flexible composition without forcing rigid class hierarchies across independent project layers.

Does opt-in composability force dependencies when adding new agent tooling layers?▼

No, opt-in composability allows projects to grow through independent layers without forcing dependencies. This architectural principle ensures new agent tooling integrates seamlessly without requiring unnecessary external libraries or rigid coupling.

What is the meta-tool pattern and how does it reduce token load for agents?▼

The meta-tool pattern reduces token load by exposing a compact, discoverable tool surface to agents. This minimizes the number of distinct tools registered while maintaining access to underlying capabilities through a unified interface.

Related Skills

Explore More Software Engineering Skills→
lushly-devlushly-dev
4

build-botcore-plugins

Guide BotCore plugin development from protocol implementation to distribution.

Official
Intermediate
duggal1duggal1
2

elite-backend-engineering

Design backend systems with explicit contracts, validation, testing, and observability.

Community
Advanced
haxlyshaxlys

threat-mitigation-mapping

Map identified threats to security controls for prioritized mitigation planning.

Community
Advanced
lushly-devlushly-dev
4

configure-botcore

Configure botcore projects via TOML files and environment variables.

Official
Intermediate