Skip to main content
Glama
LeonNonnast

Dev MCP Prompt Server

by LeonNonnast

load_skills

Load and combine multiple development skills into an agent's knowledge base to enhance AI-powered workflows for tasks like UI/UX design, debugging, and project setup.

Instructions

Load and combine multiple skills into an agent's knowledge base

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
skill_idsYesArray of skill IDs to load (e.g., ['clean-code-clarity-readability', 'testing-strategies'])
agent_nameNoOptional: name for the specialized agent (e.g. sql-expert)

Implementation Reference

  • This is the main handler for the 'load_skills' tool within the CallToolRequestSchema handler. It validates input arguments (requires skill_ids array, optional agent_name), fetches the specified skill prompts using PromptManager, optionally prepends an agent profile prompt, and constructs a formatted markdown response with a table of skills for the AI agent's context.
              case "load_skills":
                if (!args || !Array.isArray(args.skill_ids)) {
                  throw new McpError(
                    ErrorCode.InvalidRequest,
                    "skill_ids array is required"
                  );
                }
    
                const skillPrompts = [];
                for (const skillId of args.skill_ids) {
                  const skill = await this.promptManager.getPrompt(skillId);
                  if (skill) {
                    skillPrompts.push(skill);
                  }
                }
    
                if (skillPrompts.length === 0) {
                  throw new McpError(
                    ErrorCode.InvalidRequest,
                    "No valid skills found with provided IDs"
                  );
                }
    
                let resultPrompt = "";
    
                if (
                  args &&
                  args.agent_name &&
                  typeof args.agent_name === "string" &&
                  args.agent_name != ""
                ) {
                  const agentName = args.agent_name;
    
                  const agentPrompts =
                    this.promptManager.searchPromptByProfile(agentName);
    
                  const agentPrompt =
                    agentPrompts.length > 0 ? agentPrompts[0] : undefined;
    
                  if (agentPrompt) {
                    resultPrompt +=
                      "# Your Profile" +
                      "/nPlease read your profile carefully and try to imagine yourself in the role as much as possible. You embody this person.";
    
                    resultPrompt = resultPrompt + "/n" + agentPrompt.prompt;
                    resultPrompt =
                      resultPrompt +
                      +"/n/n" +
                      (agentPrompt.examples || [])?.join("/n");
                  }
                }
    
                resultPrompt +=
                  "# Your Skillset" +
                  "/nThese are your skills, please familiarize yourself with them and internalize them. It's like the religion you live. Respect the skills and be confident with them. Feel free to take notes and summarize them for yourself.";
    
                resultPrompt += `Your specialized Skills (${skillPrompts.length}):
                | title | description | examples |
                | -------- | -------- | -------- |
    
    ${skillPrompts.map(
      (skill) =>
        `| ${skill.title} | ${skill.description} | ${(skill.examples || [])
          .map((item) => item.input)
          .join("\n")} |`
    )}
    
    Please acknowledge that you have integrated these skills and are ready to apply them in your responses. Use these skills naturally when relevant to user requests.`;
    
                logger.info(`Loaded ${skillPrompts.length} skills for your agent`);
    
                return {
                  content: [
                    {
                      type: "text",
                      text: resultPrompt,
                    },
                  ],
                };
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('load and combine') but doesn't describe key traits: whether this is a read-only or mutating operation (e.g., modifies agent state), any side effects (e.g., overwrites existing skills), authentication needs, rate limits, or error handling. This is inadequate for a tool that likely alters an agent's knowledge base.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded with the core action ('load and combine'), making it easy to parse. Every part of the sentence contributes essential information, earning a top score for conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of loading and combining skills (likely a mutating operation), no annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects (e.g., side effects, permissions), return values, or error cases. For a tool that modifies an agent's state, this leaves significant gaps in understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents both parameters ('skill_ids' as an array of IDs and 'agent_name' as optional). The description adds no additional meaning beyond the schema, such as explaining how skills are combined or what happens if 'agent_name' is omitted. Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'load and combine' and the resource 'multiple skills', specifying the action and target. It distinguishes from siblings like 'list_skills' (which lists rather than loads) and 'search_profiles' (which searches profiles, not skills). However, it doesn't explicitly mention what 'load and combine' entails operationally (e.g., merging knowledge vs. sequential loading), keeping it from a perfect 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether skills must exist or be accessible), exclusions (e.g., not for single skills), or comparisons to siblings like 'list_skills' (for viewing available skills). This lack of context leaves the agent without clear usage cues.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/LeonNonnast/mcpdevprompts'

If you have feedback or need assistance with the MCP directory API, please join our Discord server