DEV Community: aiFetchly

Step-by-Step: Authoring Custom Slash Commands in aiFetchly

aiFetchly — Wed, 14 Oct 2026 15:14:17 +0000

Direct Answer: Power users author custom slash commands in aiFetchly by saving structured Markdown prompt templates with YAML frontmatter into a personal or workspace commands directory. Argument hints, {{arg}} substitution tokens, and autonomous /goal loops turn multi-clause prompts into instant keystroke shortcuts.

Prompt fatigue is a pervasive friction point in advanced agentic development workflows. As local developer environments and AI chat tools converge, engineers waste context repeatedly copy-pasting structured instructions and system constraints. The aiFetchly desktop application solves this with AI Chat V2: low-latency keystroke autocomplete, dynamic parameter injection, and a resilient four-tier command resolution hierarchy.

Here is how power users can build, configure, and execute custom slash commands in three straightforward steps.

Step 1: Create Your Command Markdown Template

Custom slash commands in aiFetchly are plain Markdown files stored inside your local commands directory (~/.aifetchly/commands/ for personal macros or .aifetchly/commands/ in your workspace root for project-wide templates). Each command requires YAML frontmatter defining its invocation trigger, human-readable description, and expected argument tokens.

Create a file named audit.md:

---
name: audit
description: "Audit security and code style for a target file"
arguments:
  - name: path
    description: "Path to source file"
    required: true
---

Review the source code at `{{path}}`. Check for unvalidated inputs, race conditions, memory leaks, and adherence to clean architecture principles. Output findings in an actionable markdown table.

When you type /audit in the chat composer, aiFetchly's autocomplete menu parses the frontmatter in milliseconds, displaying your description and prompting for the required {{path}} argument.

Step 2: Leverage the Four-Tier Scope Resolution

aiFetchly evaluates slash commands through a strict hierarchical scope structure to eliminate namespace collisions across teams:

Built-in Commands: Core primitives bundled with the client runtime, including /goal, /loop, /compact, and /model.
Workspace Commands: Shared repository templates stored in ./.aifetchly/commands/ that sync across engineering teams via version control.
User Commands: Personal productivity macros located in ~/.aifetchly/commands/ available across all your local projects.
Plugin Commands: Specialized capabilities contributed by installed extensions and Model Context Protocol (MCP) servers.

Workspace commands gracefully override user defaults, ensuring uniform review standards across collaborative projects while preserving individual developer customization.

Step 3: Chain Autonomous Execution Loops

For complex workflows, custom macros can invoke built-in autonomous loops. Chaining /goal or /loop inside your custom templates lets aiFetchly iteratively generate code, evaluate compiler errors, and refactor codebases until predefined exit criteria are met. This converts repetitive multi-turn guidance into a single, reliable command execution.

For complete frontmatter specifications and advanced templating filters, consult the official Slash Commands manual. Building modular prompt macros turns routine debugging and code generation into frictionless, repeatable keystrokes.

Which slash command would you author first — /audit, /review, or a team-specific macro?

Step-by-Step: Packaging Custom AI Skills for aiFetchly

aiFetchly — Mon, 12 Oct 2026 15:33:21 +0000

Direct Answer: Power users can extend aiFetchly by packaging modular Python or JavaScript AI Skills inside standard ZIP archives containing a validated manifest.json. This step-by-step guide walks through defining input schemas, implementing entry point logic, declaring permission tiers (pure, network, filesystem, automation), and importing skills into aiFetchly for governed conversational execution.

In 2026, automation power users require customized tools tailored to proprietary local databases, internal CLI binaries, and domain-specific APIs. While web chatbots restrict users to pre-packaged vendor plugins, desktop AI engines unlock direct host machine extensibility.

The aiFetchly desktop application introduces a modular extension engine called AI Skills. Skills are portable, lightweight bundles that allow the desktop assistant to autonomously execute specialized tasks under strict human supervision.

Here is a step-by-step tutorial on building, packaging, and importing your own custom AI Skill into aiFetchly.

Step 1: Author the `manifest.json` Specification

Every AI Skill requires a root manifest.json that defines its metadata, runtime, and parameter types. Create a new directory and draft your manifest:

{
  "name": "csv-sales-analyzer",
  "version": "1.0.0",
  "description": "Parses local sales CSV files and extracts quarterly revenue totals.",
  "runtime": "python",
  "entry": "main.py",
  "parameters": {
    "type": "object",
    "properties": {
      "file_path": { "type": "string", "description": "Absolute path to CSV file" }
    },
    "required": ["file_path"]
  },
  "permissions": ["filesystem"]
}

As detailed in the AI Skills documentation, the first entry in permissions establishes the skill’s security tier (pure, network, filesystem, or automation).

Step 2: Implement the Entry Logic

Write your executable script matching your chosen runtime (runtime: "python" or runtime: "javascript"):

Input Parsing: aiFetchly passes invocation parameters to your entry script as command-line arguments or via standard input.
Structured Output: Print the resulting data to standard output. The AI assistant ingests this output directly into its conversational context window to formulate its response.

Step 3: Bundle into a `.zip` Archive

When packaging your skill, compress the contents of the folder directly, rather than the parent directory itself:

Ensure manifest.json and your entry file (main.py or index.js) reside at the archive root.
Include any local dependencies or helper scripts within the package.
Save the resulting archive as csv-sales-analyzer.zip.

Tip for Advanced Users: You can also drop unzipped skill folders directly into your local discovery directory at~/.aifetchly/skills/<skill-name>/.

Step 4: Import and Configure Approval Policies

In aiFetchly, navigate to System Settings → Manage Skills.
Click Import (upload icon) in the upper-right corner and select your .zip archive.
aiFetchly validates the schema, verifies declared permissions, and registers the skill in your active catalog.
When testing the tool inside AI Chat, the assistant displays an interactive approval card: select Allow Once for single runs or Always Allow to authorize subsequent invocations.

By authoring custom AI Skills, power users turn repetitive desktop data processing into secure, autonomous conversational workflows.

Which custom skill would you package first — CSV, CLI, or an internal API?