Introducing Resources: Give Your AI the Context It Needs

We're excited to announce Resources—a new feature for providing reference content that your AI assistant can read and understand.

What Are Resources?

Resources are read-only content that your AI can access during conversations. Unlike commands that trigger actions, resources provide context—documentation, guidelines, specifications, and reference materials your AI needs to give better answers.

Each resource consists of:

• Name — Identifier for the resource (e.g., api-docs, coding-guidelines)
• Description — What the resource contains
• Content — The actual reference material, up to 10,000 characters

Think of resources as giving your AI assistant access to your team's knowledge base.

Why Resources Matter

Your AI Understands Your Codebase

Generic AI assistants don't know your API structure, your naming conventions, or your architectural decisions. Resources fill that gap with your specific documentation.

Consistent, Accurate Answers

When your AI references your actual API documentation instead of guessing, you get answers that work with your system—not generic examples that need heavy modification.

Share Team Knowledge

That internal wiki article explaining your authentication flow? The architecture decision record for your database schema? Make it available to your AI so it can help you work within your existing systems.

How to Create a Resource

1. Navigate to Resources

Go to your workspace and click the Resources tab. Click New Resource.

2. Define the Resource

3. Save and Enable

Click Create and enable the resource to make it available in Claude Code.

Accessing Resources

Resources are available as read-only content. Your AI assistant can:

• Read the resource content when relevant
• Reference it when answering questions
• Use it as context for code generation

The AI decides when to access resources based on the conversation context.

Example Resources

API Documentation

Name: api-endpoints
Description: REST API endpoint reference

Content:
## User API

POST /api/users
  - Create new user
  - Body: { email, password, name }
  - Returns: { id, email, name, createdAt }

GET /api/users/:id
  - Get user by ID
  - Returns: { id, email, name, createdAt }

PUT /api/users/:id
  - Update user
  - Body: { name?, email? }
  - Returns: updated user object

DELETE /api/users/:id
  - Delete user
  - Returns: { success: true }

## Authentication

POST /api/auth/login
  - Body: { email, password }
  - Returns: { accessToken, refreshToken }

POST /api/auth/refresh
  - Body: { refreshToken }
  - Returns: { accessToken }

Database Schema

Name: database-schema
Description: Core database table structures

Content:
## Users Table
- id: UUID (primary key)
- email: VARCHAR(255) UNIQUE NOT NULL
- password_hash: VARCHAR(255) NOT NULL
- name: VARCHAR(100)
- created_at: TIMESTAMP DEFAULT NOW()
- updated_at: TIMESTAMP

## Posts Table
- id: UUID (primary key)
- user_id: UUID (foreign key -> users.id)
- title: VARCHAR(200) NOT NULL
- content: TEXT
- status: ENUM('draft', 'published', 'archived')
- published_at: TIMESTAMP
- created_at: TIMESTAMP DEFAULT NOW()

## Comments Table
- id: UUID (primary key)
- post_id: UUID (foreign key -> posts.id)
- user_id: UUID (foreign key -> users.id)
- content: TEXT NOT NULL
- created_at: TIMESTAMP DEFAULT NOW()

Architecture Guidelines

Name: architecture-guidelines
Description: System architecture decisions

Content:
## Architecture Principles

1. **Microservices Communication**
   - Use async messaging (SQS) for cross-service communication
   - Sync HTTP only for user-facing API responses
   - Event-driven for background processing

2. **Data Storage**
   - PostgreSQL for relational data
   - Redis for caching and sessions
   - S3 for file storage

3. **API Design**
   - RESTful endpoints for CRUD operations
   - GraphQL for complex queries (read-only)
   - Versioning via URL path (/api/v1/)

4. **Error Handling**
   - Structured error responses: { error, message, details }
   - HTTP status codes: 4xx for client errors, 5xx for server
   - Log all errors with correlation IDs

Coding Conventions

Name: coding-conventions
Description: Team coding standards

Content:
## TypeScript Conventions

- Use strict mode
- Prefer interfaces over types for objects
- Use enums for fixed sets of values
- No any types—use unknown if needed

## Naming
- camelCase for variables and functions
- PascalCase for classes and interfaces
- SCREAMING_SNAKE_CASE for constants
- kebab-case for file names

## Functions
- Max 20 lines per function
- Single responsibility
- Early returns over nested conditionals
- Async/await over .then() chains

## Testing
- Test file: [name].test.ts
- Describe blocks mirror module structure
- One assertion concept per test
- Mock external dependencies

Export and Import

Export as JSON

Export any resource as a JSON file. Click the menu on a resource card and select Export as JSON.

The JSON format:

{
  "name": "api-endpoints",
  "description": "REST API endpoint reference",
  "type": "document",
  "content": "## User API\n\nPOST /api/users..."
}

Import Resources

Click Import next to New Resource, drag and drop your JSON file, and it's added to your workspace. Names are auto-incremented if duplicates exist.

Resources vs Commands

Both are available to your AI, but they serve different purposes:

Use Resources for: API docs, schemas, guidelines, conventions, architecture decisions.

Use Commands for: Code reviews, test generation, refactoring, specific analysis tasks.

Document and URL resources

Every resource is one of two types, chosen when you create it (the type is locked afterward):

• Document — embedded markdown content (up to 10,000 characters), authored in the editor. This is the classic resource.
• URL — an external web page delivered as a link instead of embedded text, shown with a globe icon. When the AI reads a URL resource it gets a short heads-up plus the URL and fetches the page itself with its web-fetch tool if one is available — you don't configure anything on the agent side. The URL must be a public http(s) page the agent can reach.

URL resources are perfect for living documents — a changelog, an API reference, a status page — where you want the AI to pull the latest version on demand rather than a snapshot you have to keep re-pasting.

Best Practices

Keep Resources Focused

One resource per topic. Instead of one massive "everything" resource, create separate resources for API docs, database schema, and coding guidelines.

Update Regularly

Resources should reflect your current systems. When your API changes, update the resource. Outdated documentation leads to outdated AI suggestions.

Be Concise

A document resource holds up to 10,000 characters. Focus on the essential information your AI needs — or, for content that lives elsewhere, use a URL resource and let the AI fetch it.

Use Clear Formatting

Markdown formatting helps both humans and AI parse the content. Use headers, lists, and code blocks.

Limits

• Name: Up to 30 characters, lowercase with hyphens
• Description: Up to 200 characters
• Content: Up to 10,000 characters (document resources)
• Type: Document (markdown) or URL (external page); locked after creation
• Workspace: 1 resource on free, up to 250 on paid

Get Started

Resources are available now in all SuperClawd workspaces.

1. Go to app.superclawd.com
2. Navigate to the Resources tab
3. Click New Resource or Import
4. Start building your knowledge base

Have feedback or ideas for Resources? Join the GitHub Discussions or reach out through our support page.

Pro tip: Start with your most-referenced documentation—the stuff you copy-paste into AI chats repeatedly. That's your first resource.