AI Developer Tools

Validate skill definitions across OpenClaw, Claude, Codex, and MCP with portability scoring and exact fixes

Convert one canonical skill definition into OpenClaw SKILL.md, Claude blocks, Codex scaffolds, and MCP manifest snippets

Build deterministic regression suites for skill updates with risk-weighted pass-rate gates and CI-ready case definitions

Detect cross-scope skill version and enabled-state collisions across global, user, project, and local configuration layers

Plan which agent skills to keep, compress or defer when their combined token payload exceeds the context window minus reserved tokens.

Compile cross-platform allow, ask, and deny decisions for tool capabilities across Codex, Claude, and managed MCP policies

Generate staged canary rollout plans for skill updates with deterministic stop conditions and rollback checklists

Classify failed trace events into root-cause buckets and output deterministic remediation guidance for agent incident triage

Validate robots.txt and llms.txt files, detect conflicts, simulate AI bot access, and export corrected policies

Compose managed MCP governance packs with allow/deny lists, approval boundaries, and operator rollout checklists

Simulate context-window usage for full MCP tool injection versus search-first retrieval strategies

Diff managed, user, project, and local settings scopes and compute the effective merged Claude configuration

Simulate Claude hook decisions for pre/post tool events and validate policy rule coverage before rollout

Scan SKILL.md instructions for destructive command patterns, missing safety boundaries, and trust posture

Map tool capability blast radius, score operational risk, and produce least-privilege policy buckets

Compare AI models side by side: pricing, context windows, max output, and release dates

Browse and search Model Context Protocol (MCP) servers by category, with GitHub stars, transport type and copyable install commands.

Compare AI agent frameworks such as LangChain, CrewAI, AutoGen and Mastra by language, GitHub stars, multi-agent, tool, RAG and MCP support.

Calculate daily, monthly and yearly LLM API costs per model from your request volume and average input and output tokens.

Count tokens for GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Qwen and Muse models and estimate API cost. Also available as a REST API.

Generate CLAUDE.md, .cursorrules, copilot-instructions.md, .windsurfrules and .clinerules files from one form or a stack template.

Answer 7 questions and get personalized AI model recommendations across GPT, Claude, Gemini, Grok, DeepSeek, and open-weight models

Browse and copy curated system prompts for coding, writing, analysis, business, education and creative tasks, searchable by keyword.

Generate MCP server configurations for Claude Desktop, Cursor, and Windsurf with visual editor and presets

Generate Draft-07 or 2020-12 JSON Schemas from sample JSON for function calling, structured outputs and validation. Also available as a REST API.

Build AI prompt templates with variables, live preview, and export to JSON/YAML

Estimate monthly or annual LLM API costs per model from workload presets, request volume, token counts and prompt-cache hit rate.

Write and analyze AI system prompts with live token counting, variable detection, and XML highlighting

Compare two to four LLM outputs side by side, diff any pair by line or by word, and compare response length in characters and words.

Visualize how your AI model's context window is allocated across system prompt, tools, conversation, and RAG

Compare two to four prompt variants side by side with word-level diffs, token estimates and the {{variables}} each one uses.

Split a model's context window across system prompt, tools, memory, retrieved documents and history, with a warning when allocation passes 80%.

Build AI tool definitions in a visual editor with typed, enum and nested parameters, and export them as OpenAI, Anthropic, MCP or JSON Schema.

Validate LLM JSON output against a JSON Schema, with OpenAI, Anthropic and MCP presets, per-field fixes and sample output. Also has a REST API.

Build markdown memory files for AI agents from guided forms: SOUL.md, USER.md, AGENTS.md, daily logs, decision records, project status and lessons.

Compare two embedding vectors by cosine similarity, dot product, Euclidean and Manhattan distance, with dimension hints for common embedding models.

Recommend a RAG chunk size, overlap and chunking strategy from document type, query type and embedding model, with a context-window token budget.

Inspect AI agent traces from LangChain runs, OpenAI Assistants run steps or a JSON step array, with LLM calls, tool calls, errors, timings and tokens.

Diff two prompt versions line by line, with markers for template variables, XML tags and instruction keywords, plus added variables and token delta.

Write keyword and regex guardrail rules that block, flag or redact text, test them against sample inputs and outputs, and export them as JSON.

Script a multi-step tool-calling conversation with mock tool results and errors, then export it as an OpenAI or Anthropic request body.

Identify an AI API key's provider from its prefix (Anthropic, OpenAI, OpenRouter, Groq, Google AI, xAI and more) and check its format locally.

Paste text to estimate its tokens and compare input and output cost across GPT, Claude, Gemini and other catalog models, with CSV export.

Validate WebMCP tool definitions or a webmcp.json manifest against lint rules, test them with a form built from the schema and preview discovery.

Generate a runnable MCP server project in TypeScript, Python or Go with tools, resources, prompts, stdio or HTTP transport and optional auth.

Generate .cursorrules, .windsurfrules, .clinerules, CLAUDE.md or Copilot instructions from your stack, conventions, testing approach and rules.

Compare up to four LLM responses side by side, with line or word diffs and an analysis of length, shared sentences and content unique to each.

Estimate a system prompt's tokens for Claude, GPT, Llama and Gemini, its share of a 4K to 200K context window, and its template variables.

Validate a WebMCP tool definition's name, description and inputSchema, generate a test form from the schema, and mock a call locally.

Convert pasted HTML or a fetched URL to Markdown for LLM input, dropping scripts, navigation and footers, and estimate the token savings.

Scan code for AI-generated anti-patterns: hallucinated imports, over-abstraction, verbose error handling, redundancy, security smells and AI tells.

Price a multi-step LLM pipeline (embed, retrieve, generate, validate) per run, day and month, with cached-input rates and a provider comparison.

Pack code files into an LLM prompt under a token budget with per-file truncation (full, signatures, first N lines) and XML, Markdown or plain output.

Check a system prompt's defenses against known injection patterns: role hijacking, instruction override, delimiter abuse, encoding tricks, jailbreaks.

Decode an error response from the OpenAI, Anthropic, Gemini, Mistral or Cohere API into its cause, a Python and Node.js fix and a retry strategy.

Simulate multi-agent LLM costs with per-turn context growth and tool-call overhead, compare against a single agent and project monthly spend.

Lint CLAUDE.md, .cursorrules, and copilot-instructions files for redundancy, conflicting instructions, missing sections, and token efficiency.

Paste a git diff and see token counts per file, cost across AI models for code review, and chunking suggestions when diffs exceed context limits.

Estimate time to first token, generation time and total latency for current LLMs from your token counts, with a UX pattern for each wait.

Plan a prompt A/B test: sample size per variant from a two-proportion z-test with Bonferroni correction, cost, duration and a Markdown plan.

Audit an MCP server config for risky capabilities, dangerous combinations such as file read plus network, risk scores and least-privilege fixes.

Score Markdown docs on structure, code examples, API discoverability, schema coverage, LLM parseability and readability, with fixes ranked by impact.

Track deprecation and shutdown dates for API models from OpenAI, Anthropic, Google, xAI and others, with each replacement and its breaking changes.

Validate OpenAI or Anthropic fine-tuning JSONL row by row for schema, role order, token counts and duplicates, with per-row issues and summary stats.

Compute prompt-caching breakeven and monthly savings from your static prefix, query tokens and call volume for every current model with cache pricing.

Build an LLM-as-judge rubric with weighted criteria on Likert, pass/fail, percentage or 0/1 scales, then export YAML, JSON and a judge prompt.

Build a golden eval dataset of prompt, expected, category and tag rows, remove duplicates, check category balance, and export to four eval formats.

Decode an Anthropic Messages SSE stream into text, thinking and tool_use blocks, stop_reason and token usage including cache writes and reads.

Generate an AGENTS.md for coding agents from Node, Python, Go or monorepo presets, with setup, build, test and lint commands and done criteria.

Generate an llms.txt file with an H1, summary blockquote and Markdown link sections, or validate an existing one for structure and absolute URLs.

Show a prompt's token boundaries as a heatmap and flag zero-width, non-breaking and bidirectional control characters that change how a model reads it.

Generate a valid example JSON payload from a JSON Schema, honoring types, enums, required fields, formats, bounds and local $ref references.