home / skills / jeremylongshore / claude-code-plugins-plus-skills / clay-hello-world

This skill guides you through creating a minimal Clay hello world example to validate setup and start coding.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill clay-hello-world

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.2 KB
---
name: clay-hello-world
description: |
  Create a minimal working Clay example.
  Use when starting a new Clay integration, testing your setup,
  or learning basic Clay API patterns.
  Trigger with phrases like "clay hello world", "clay example",
  "clay quick start", "simple clay code".
allowed-tools: Read, Write, Edit
version: 1.0.0
license: MIT
author: Jeremy Longshore <[email protected]>
---

# Clay Hello World

## Overview
Minimal working example demonstrating core Clay functionality.

## Prerequisites
- Completed `clay-install-auth` setup
- Valid API credentials configured
- Development environment ready

## Instructions

### Step 1: Create Entry File
Create a new file for your hello world example.

### Step 2: Import and Initialize Client
```typescript
import { ClayClient } from '@clay/sdk';

const client = new ClayClient({
  apiKey: process.env.CLAY_API_KEY,
});
```

### Step 3: Make Your First API Call
```typescript
async function main() {
  // Your first API call here
}

main().catch(console.error);
```

## Output
- Working code file with Clay client initialization
- Successful API response confirming connection
- Console output showing:
```
Success! Your Clay connection is working.
```

## Error Handling
| Error | Cause | Solution |
|-------|-------|----------|
| Import Error | SDK not installed | Verify with `npm list` or `pip show` |
| Auth Error | Invalid credentials | Check environment variable is set |
| Timeout | Network issues | Increase timeout or check connectivity |
| Rate Limit | Too many requests | Wait and retry with exponential backoff |

## Examples

### TypeScript Example
```typescript
import { ClayClient } from '@clay/sdk';

const client = new ClayClient({
  apiKey: process.env.CLAY_API_KEY,
});

async function main() {
  // Your first API call here
}

main().catch(console.error);
```

### Python Example
```python
from clay import ClayClient

client = ClayClient()

# Your first API call here
```

## Resources
- [Clay Getting Started](https://docs.clay.com/getting-started)
- [Clay API Reference](https://docs.clay.com/api)
- [Clay Examples](https://docs.clay.com/examples)

## Next Steps
Proceed to `clay-local-dev-loop` for development workflow setup.

Overview

This skill provides a minimal, working Clay example to verify setup and demonstrate core Clay API usage. It helps you initialize a Clay client, make a first request, and confirm connectivity with concise, runnable code. Use it as a starting point before building more complex integrations.

How this skill works

The skill shows how to create a tiny entry file, import and initialize the Clay client, and run a simple API call that returns a success message. It inspects your environment for valid credentials and demonstrates basic error handling scenarios like import errors, auth failures, timeouts, and rate limits. Output is a small script you can run locally to confirm the Clay connection works.

When to use it

  • Starting a new Clay integration or playground project
  • Verifying Clay SDK installation and authentication
  • Testing environment variables and network connectivity
  • Learning basic Clay client initialization and call patterns
  • As a quick smoke test before running more complex examples

Best practices

  • Ensure Clay API credentials are set as environment variables before running the script
  • Run a single, simple API call first to confirm auth and networking
  • Wrap the main call with try/catch and report clear error messages
  • Use exponential backoff for retries when hitting rate limits
  • Move from the minimal example to a local dev loop for iterative development

Example use cases

  • Quickly validate Clay SDK installation and environment configuration
  • Teach new team members how to initialize and call the Clay client
  • Integrate the minimal script into CI to smoke-test credentials and connectivity
  • Use as a template to build out a larger Clay-based feature or automation
  • Compare TypeScript and Python client initialization approaches in a tutorial

FAQ

What do I need before running the example?

Complete the Clay install/auth setup and ensure your Clay API key is available in environment variables.

What should I do if I get an auth error?

Verify the API key is set correctly and not expired. Re-run the auth setup and check environment variable spelling.