More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Quill Delegate: Hand Coding Tasks to a Local Model

    1

    Your agent hands well-scoped coding tasks to the model on your own machine through Quill Code, in an isolated git worktree, then reviews and applies the result.

    Free

    1 useSecurity scanned
    Quill Delegate: Hand Coding Tasks to a Local Model

    Quill Delegate: Hand Coding Tasks to a Local Model

    Example session with this skill installed

    npm test fails in this project. Use the quill-delegate skill to have my local model fix it, then check its work and apply it here. Do not commit.

    • Read your context and instructions
    • Compiled the quill delegate

    npm test passes now, 2 of 2, and nothing is committed.

    What was wrong: slugify in src/slug.js turned each space into its own dash and left punctuation in. So "Hello World" came out as hello---world and " Ship it, now! " as --ship-it,-now!--.

    The fix: your local model, llama-cpp/qwen3.5-35b-a3b-vl, wrote it through Quill in an isolated worktree in about 37 seconds. It changed only src/slug.js; the tests are untouched. The function now lowercases the title, removes punctuation, joins words with dashes and strips dashes from the ends.

    My review:

    • The diff stayed inside the brief and the tests passed in Quill's worktree.
    • I made one change before applying it. The model's version would turn "a - b" into a---b, because it didn't merge an existing dash with the spaces around it. I changed the dash-joining step to treat spaces and dashes together (/[\s-]+/g) and simplified the end-trimming regex.
    • After applying the patch here, I ran npm test in your checkout and both tests passed. The Quill worktree has been removed.

    One gap: my quick check of "a - b" and the file's last bytes was blocked by a permission prompt, so the edge-case fix is checked by reading the code only. I'd expect slugify('a - b') to return a-b.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Your agent stays in charge, but hands routine, self-contained coding work to the model running on your own machine through Quill Code, a free, MIT-licensed terminal coding agent for local models (https://github.com/Smoffyy/quill-code).

    What it does

    1. Checks that the quill CLI is installed and a model server is running (quill models).
    2. Decides whether the task suits a local model: a failing test with a clear error, a rename, tests that follow an existing pattern, boilerplate, a small refactor. Judgment calls, security-sensitive code and vague requirements stay with your agent.
    3. Writes a brief the local model can follow on its own: the goal, the files, the command that proves it worked, and what not to touch.
    4. Runs quill exec -w, so the work happens in a separate git worktree and your checkout is not touched.
    5. Reviews the diff, runs the check itself, fixes small issues, applies the patch and removes the worktree.
    6. Tells you what changed and which local model wrote it. Nothing is committed unless you ask.

    Why use it

    • Routine work stops spending your cloud tokens.
    • The first pass at your code never leaves your machine.
    • You still get a reviewed result, not raw local-model output.

    Requirements

    • Quill Code 1.0 or newer
    • git
    • A local model server: llama.cpp, LM Studio, Ollama, vLLM, Jan, GPT4All or any OpenAI-compatible server, running a model that supports tool calls

    Tested end to end with Claude Code and Qwen 3.5 35B-A3B on llama.cpp. A 9B model or larger is recommended.

    Install Quill Code

    macOS and Linux:

    curl -fsSL https://github.com/Smoffyy/quill-code/releases/latest/download/install.sh | sh
    

    Windows (PowerShell):

    irm https://github.com/Smoffyy/quill-code/releases/latest/download/install.ps1 | iex
    

    The installer checks the download against the release's checksums and needs no admin rights. Then open a new terminal in a project and run quill once: it finds your model server and lets you pick a model. If Quill is missing when you use the skill, your agent shows you these commands.

    What's inside

    • SKILL.md: the workflow
    • references/routing.md: which tasks to delegate, and how to split a larger job
    • references/exec-events.md: the quill exec --json event stream, for tool-level detail
    • LICENSE: MIT

    Requires Quill CLI, Git, and a running local model server. Only handles tasks in local Git repositories with at least one commit. Cannot perform interactive approvals during execution.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 28 days ago

    • Free with an Agensi account

    Requires

    Quill Code (quill CLI)
    Git
    llama.cpp, LM Studio, Ollama or vLLM
    macOS

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    The agent runs quill and git in the terminal, reads the diff in an isolated git worktree, and applies the reviewed change to your project files. Quill only talks to the local model server you configured, usually on localhost. The skill itself makes no network calls and reads no credentials.

    Listed28 days ago

    What's inside

    Frequently Asked Questions

    Your agent writes a brief the local model can follow on its own, Quill does the work in a separate git worktree, and your agent reviews the diff and runs the tests before anything reaches your checkout. You get a checked result instead of raw local-model output, and your working copy is never touched mid-task.

    It requires the Quill Code CLI (version 1.0 or higher), Git, and an active local inference server such as Ollama, LM Studio, or vLLM to process the code changes locally.

    Yes, the skill is designed to work across Windows, macOS, and Linux, provided your system has the hardware to run local models and a compatible shell for the Quill CLI.

    Partly. The work the local model does stays on your machine: Quill sends the brief and the files it reads only to your own model server. Your main agent still reads the task, the diff and the test results, so if that agent is a cloud service, that part goes to it as usual. For code that must never leave your machine, run Quill directly instead.

    Results depend on your local model: small models handle mechanical tasks well but struggle with design decisions, which is why the skill keeps those with your main agent. The project must be a git repository with at least one commit, and uncommitted changes are not copied into the worktree, so the skill asks before working on top of them.

    The skill includes the logic for model routing, automated briefing, Git worktree orchestration, and patch application, but it does not include the Quill CLI or the LLM models themselves.

    New in Agents & Orchestration