AI Project Learner

Generate a concept dependency graph for AI projects. Identifies what you need to learn, in what order, adapted to project complexity.

Security Scan

The skill's code, instructions, and requested environment variable (SKILLPAY_API_KEY) are consistent with its stated purpose of charging via SkillPay and returning learning-graph data; nothing in the package suggests unrelated access or hidden exfiltration.

Purpose & Capability

The skill claims to charge users $0.01 via SkillPay and generate a concept dependency graph. The only required secret is SKILLPAY_API_KEY and the code implements a Cloudflare Worker that calls SkillPay's billing endpoint — this is proportionate and expected for a paid skill.

Instruction Scope

SKILL.md instructs the agent to POST a charge request to the skill's worker endpoint and then build the concept graph from the user's project text. The instructions do not ask the agent to read unrelated files or credentials. Minor mismatch: SKILL.md mentions POST /charge while the Worker code accepts POST to the worker root (it doesn't validate pathnames) — functional but not harmful.

Install Mechanism

There is no install script; this is instruction-plus-worker source. The package references Cloudflare Worker tooling (wrangler) and dev deps only. No external arbitrary downloads or extract steps are present in the manifest.

Credentials

Only SKILLPAY_API_KEY is required. That key is used solely to call the SkillPay billing API in billing.ts. No unrelated credentials or high-privilege env vars are requested.

Persistence & Privilege

The skill is not always-enabled and uses normal model invocation. It does not modify other skills or system settings. The worker expects an env var but otherwise has no privileged persistence requirements.

Assessment

This skill appears coherent: it charges via SkillPay and then builds learning graphs. Before installing, confirm you trust the skill author and SkillPay for billing, and avoid reusing the same SKILLPAY_API_KEY across unrelated services. If you plan to run the worker yourself, verify the endpoint URL and review the small worker code (billing.ts and index.ts). If you want extra caution, provision a SkillPay API key with limited scope or a test account/key that can only perform billing for this skill.

Generate a concept dependency graph for users building projects with AI. Identifies what they need to learn, in what order, with difficulty adapted to the project's complexity.

How to Use This Skill

Step 1: Charge billing

POST to the skill endpoint to authorize payment:

POST https://ai-project-learner.swmengappdev.workers.dev/charge
Content-Type: application/json

{"user_id": "<user_id>"}

If successful, you'll receive {"success": true}. If payment fails, you'll receive a payment_url to share with the user.

Step 2: Analyze the project

From the user's project description, determine:

Complexity level:

• beginner — Uses a single API or library, straightforward pipeline (e.g., "chatbot using OpenAI API", "sentiment classifier with HuggingFace")
• intermediate — Combines multiple AI techniques, has data pipeline or custom logic (e.g., "RAG chatbot with custom embeddings", "multi-agent workflow")
• advanced — Involves fine-tuning, custom model architectures, or production-scale systems (e.g., "fine-tuned LLM for legal documents", "real-time ML pipeline with feature store")

Domain: Classify into one of: nlp, cv (computer vision), agents, data, multimodal, generative, mlops, other

Step 3: Build the concept dependency graph

Generate 8-20 concepts (scale with complexity: beginner ~8, intermediate ~12-15, advanced ~15-20).

For each concept, provide:

• id — kebab-case identifier (e.g., text-embeddings)
• name — Human-readable name (e.g., "Text Embeddings")
• description — 1-2 sentence explanation of what it is and why it matters for this project
• difficulty — Integer 1-5 (1=fundamental, 5=advanced)
• prerequisites — Array of concept ids that should be understood first

Rules for building the graph:

• Every concept's prerequisites must reference other concepts in the graph
• Concepts with no prerequisites are entry points (difficulty 1-2)
• No circular dependencies
• Order concepts so prerequisites always appear before dependents
• Descriptions should be practical ("what it is + why you need it for this project"), not academic
• Difficulty should be calibrated to the project: a beginner project should have mostly difficulty 1-3 concepts, an advanced project can have difficulty 4-5 concepts

Concept categories to consider (pick relevant ones):

• Foundations: LLMs, APIs, prompting, tokens, context windows
• Data: embeddings, vector databases, chunking, preprocessing
• Architecture: RAG, agents, chains, tool use, memory, planning
• Training: fine-tuning, RLHF, LoRA, evaluation, datasets
• Production: deployment, monitoring, caching, rate limiting, cost optimization
• Safety: guardrails, content filtering, hallucination detection, red teaming

Step 4: Compute learning order

Produce a topologically sorted learning_order array of concept ids. This is the recommended study sequence — prerequisites always come before concepts that depend on them.

Step 5: Estimate total learning time

Estimate estimated_hours as a total for all concepts. Use these rough heuristics:

• Difficulty 1 concept: ~1 hour
• Difficulty 2 concept: ~1.5 hours
• Difficulty 3 concept: ~2.5 hours
• Difficulty 4 concept: ~4 hours
• Difficulty 5 concept: ~6 hours

Output Format

Return the result as JSON:

{
  "project": "<user's project description>",
  "complexity": "beginner|intermediate|advanced",
  "domain": "nlp|cv|agents|data|multimodal|generative|mlops|other",
  "concepts": [
    {
      "id": "llm-basics",
      "name": "Large Language Models",
      "description": "Neural networks trained on vast text data that can generate and understand language. The foundation of your chatbot project.",
      "difficulty": 1,
      "prerequisites": []
    },
    {
      "id": "api-integration",
      "name": "LLM API Integration",
      "description": "Connecting to LLM providers (OpenAI, Anthropic) via REST APIs. How you'll send prompts and receive responses.",
      "difficulty": 1,
      "prerequisites": ["llm-basics"]
    }
  ],
  "learning_order": ["llm-basics", "api-integration"],
  "estimated_hours": 15
}

Pricing

$0.01 USDT per call via SkillPay.me