New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

TiXL Ticket Processor

by tixl3d in tixl3d/tixl

Works through the In progress column of the TiXL road-map board unattended, turning simple tickets into git stashes and writing plans for the rest under .agentic/Plans.

MITAuto-check passedDevelopment

Install TiXL Ticket Processor

skills CLI
$ npx skills add tixl3d/tixl --skill process-tickets -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install tixl3d/tixl process-tickets --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/tixl3d/tixl.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/process-tickets .claude/skills/process-tickets && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
process-tickets
GitHub stars
5.1k
Token cost
~2.6k tokens
SKILL.md length
1,379 words
Files
1
Skills in repo
5
Repo updated
First seen
Licence
MIT

At a glance

Works through the In progress column of the TiXL road-map board unattended, turning simple tickets into git stashes and writing plans for the rest under .agentic/Plans.

  • Works in 4 steps: protect the user's current work → list the queue → per-ticket loop (no prompts) → …
  • Working through the in-progress tickets on the TiXL board
  • SKILL.md covers Hard invariants — never…, Prerequisites — check before…, Step 0 — protect the user's… and Step 1 — list the queue, plus 3 more sections
  • Calls git, dotnet and gh

What it does

The skill runs without asking questions across the In progress column of the TiXL road-map GitHub board. Each ticket yields one reviewable artifact: a git stash holding an implemented code change, or a plan file under .agentic/Plans/ for anything too involved to guess at. You review and commit the results later.

Hard rules keep it safe. GitHub is read-only, with no comments, labels, card moves or edits. There are no commits, git add or push. Only new stashes are created, and existing ones are never popped, applied or dropped, and code changes start from a clean main so every stash is an independent diff. Plan files stay in the working tree because git GUIs hide untracked files inside a stash. Before starting it checks the read:project token scope, that Scripts/board-tickets.ps1 exists and that .agentic/AGENT_INSTRUCTIONS.md has been read.

When your agent uses it

  • Working through the in-progress tickets on the TiXL board
  • Batch-processing a backlog while you are away
  • Producing plans for tickets too big to implement blindly

Example prompts

  • “/process-tickets”
  • “Process the In progress column of the TiXL board and leave stashes and plans for me to review.”
  • “Work the board backlog unattended, with no commits please.”

Requirements

  • GitHub CLI with the read:project token scope
  • PowerShell, for Scripts/board-tickets.ps1
  • A TiXL checkout containing .agentic/AGENT_INSTRUCTIONS.md

Workflow steps

4 steps, taken from the step headings in SKILL.md.

  1. protect the user's current work
  2. list the queue
  3. per-ticket loop (no prompts)
  4. final report

What it can do on your machine

Read from SKILL.md and the folder at commit 9ce9691. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • dotnet
    • gh

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git and gh, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

TiXL Ticket Processor loads about 2.6k tokens when it runs. Until then it costs about 96 tokens; SKILL.md has 1,379 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~96
When it runs · the whole SKILL.md, loaded when a task matches
~2.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from tixl3d/tixl at commit 9ce9691, republished under its MIT licence (© tixl3d). 1,379 words, ~2,601 tokens.

Download SKILL.mdSave it as .claude/skills/process-tickets/SKILL.md (or your agent's skills folder).
name
process-tickets
description
Unattended batch over the "In progress" column of the TiXL road-map GitHub board. Implements straightforward tickets as individual git stashes and writes plans for the rest as files in .agentic/Plans/ — no questions, no commits, no GitHub writes. Use when the user wants to work through their In-progress tickets, process the board backlog, or invokes /process-tickets.

process-tickets

Work the In progress column of the TiXL road-map board (org tixl3d, project 3, "TiXL road map") unattended. Each ticket produces one reviewable artifact: a git stash for an implemented code change, or a plan file in .agentic/Plans/ for everything else. The user sifts these later at their leisure.

Why the split: git GUIs (e.g. git Fork) do not show untracked files stored inside a stash, so a stashed new plan doc looks empty in review — useless. Code edits are tracked-file diffs and show fine in a stash; new plan files belong in the working tree, where they appear under Local Changes and get committed to .agentic/Plans/.

This is the user's intentionally messy inbox: they collect ideas as In progress, and push anything too involved to Todo / a later milestone themselves. So most tickets are small; the rest should become a plan, not a guess.

Hard invariants — never violate these

  • Read-only on GitHub. Never comment, close, label, move cards, or edit issues/the board. The helper script only reads. There is no write path and you must not add one.
  • No commits, no git add, no git push. The user reviews and commits everything themselves. Touching the index or committing defeats the whole workflow.
  • Only ever create stashes. Never pop, apply, or drop an existing stash. The user keeps live WIP in stashes (e.g. keep/...); destroying one loses real work.
  • Run unattended — do not ask the user questions mid-run. That's the point: they fire it and walk away. Resolve every "should I…?" by the classifier below, biasing to plan.
  • Code changes → one stash each (return to clean main between them, so each stash is an independent diff). Plan files → left in the working tree, never stashed.

Prerequisites — check before doing anything else

  1. read:project scope. Run .\Scripts\board-tickets.ps1 -List. If it prints an INSUFFICIENT_SCOPES hint, stop and tell the user to run gh auth refresh -s read:project, then re-invoke. (Projects v2 is GraphQL-only; a public board still needs the token scope.)
  2. Helper script present. Scripts/board-tickets.ps1 must exist. If not, the skill is incomplete — tell the user.
  3. Conventions loaded. Read .agentic/AGENT_INSTRUCTIONS.md if you haven't this session. Every code edit must follow it (no per-frame allocations/LINQ, UiColors.*, Guid over direct refs, * T3Ui.UiScaleFactor on pixel literals, brace every branch, CRLF unless the file is LF, minimal scoped diffs, no plan references in comments).

Parsing the helper output: use the argument form ConvertFrom-Json (.\Scripts\board-tickets.ps1 -List), not the pipe form — Windows PowerShell 5.1's ConvertFrom-Json mis-handles a piped JSON array.

Step 0 — protect the user's current work

Run git status --short. If the working tree is dirty, the user has uncommitted work; an unattended run must not lose it. Stash it first under a clearly-marked name:

powershell
git stash push -u -m "keep/before-ticket-run"

Note in the final report that you did this so the user pops it back. If the tree is clean, proceed. Never drop or pop any pre-existing stash.

Step 1 — list the queue

powershell
$tickets = ConvertFrom-Json (.\Scripts\board-tickets.ps1 -List)

Each record has: number, title, url, repo, size (S/M/L/XL/XXL or empty), milestone, labels, body.

Build the already-processed set from two places (re-runs are idempotent):

  • Code: git stash list — every ticket number appearing as a ticket #<n> marker.
  • Plans: .agentic/Plans/ — any file (tracked or not) whose body has a Ticket: #<n> line.

Skip a ticket if it shows up in either.

Every ticket leaves an artifact — including non-actionable ones. A board test stub (empty body + trivial title like "Test"), an infeasible request, or one that only raises questions still gets a plan file saying exactly that (see 2c-iii). No silent skips — that keeps the record complete and re-runs idempotent.

Step 2 — per-ticket loop (no prompts)

For each remaining ticket, in board order:

2a. Read it

Use the body from the list (or re-fetch with -Ticket <n>). Understand what's actually being asked. Locate the relevant code with Grep/Glob/Read (or an Explore agent for wide searches). Don't start editing until you know which files are in play.

2b. Classify — implement now, or write a plan?

Implement now only when all hold:

  • The requirement is unambiguous — one obvious correct behavior, no design decision to make.
  • The change is localized (roughly ≤ 3 files) and additive/low-risk.
  • Size is S/M (or unset but clearly small).
  • No data-model / serialization / saved-project / migration impact.
  • No operator rename/removal or input-set change (those break user projects).
  • For UI tickets: the visual and interaction design is already determined by the ticket or by an obvious existing pattern. Per AGENT_INSTRUCTIONS, UI design is not something to guess unattended — if the look or interaction is open, it's a plan.

Write a plan when any hold:

  • Size L/XL/XXL, or the change is cross-cutting / architectural.
  • Touches Symbol/serialization/data model/migration, or renames/removes operators or params.
  • The requirement is vague, exploratory ("Idea: …"), or needs a design/UX decision.
  • The build can't be made green with a minimal, confident change.

When genuinely unsure, write a plan — a discarded plan costs seconds; broken unattended code costs an untangling session.

Show full SKILL.md (573 more words)Show less
2c-i. If implementing
  • Edit minimally, following .agentic/AGENT_INSTRUCTIONS.md. No opportunistic refactors.
  • Build the affected project (infer it from the changed path — Core, Editor, Operators/Lib, …):
    powershell
    dotnet build <project>.csproj
  • Green → stash it (2d).
  • Can't go green with a minimal fix → revert your edits (git restore <files> for tracked files; delete any new files you created), and fall through to a plan (2c-ii) instead. Never stash broken code.
2c-ii. If planning

Write .agentic/Plans/Plan_<PascalCaseSlug>.md (slug from the title) and leave it in the working tree — do not stash it. It then appears under Local Changes for the user to review and commit to .agentic/Plans/. The Ticket: #<number> line below is what the next run greps to skip it. Keep it concise:

markdown
# <Title>

Ticket: #<number> — <url>
Size: <size>   Milestone: <milestone>

## Problem
<1-3 sentences: what the ticket wants and why it isn't a trivial edit.>

## Affected code
<files / systems involved, with paths.>

## Proposed approach
<the plan in a few bullets.>

## Risks / side-effects
<serialization, migration, perf, UX, cross-feature overlap.>

## Open questions
<decisions the user must make before this can be implemented.>

Do not reference this plan path from any source-code comment (AGENT_INSTRUCTIONS).

2c-iii. If not actionable (still write a plan)

A ticket that is a test stub, infeasible, or only raises questions you can't resolve unattended still gets a plan file (in the working tree, not stashed) — never a contentless skip. Write the same file, but the body states the situation honestly:

  • Test stub / no content → "Appears to be a placeholder; no work taken. Add a description to have it picked up next run."
  • Infeasible → why it can't be done as asked, and what would have to change first.
  • Needs clarification → the specific questions that block it, under ## Open questions.

This guarantees every ticket produces exactly one artifact, so nothing is silently dropped.

2d. Stash implemented code changes (code tickets only)

Only implemented tickets get stashed — plan files (2c-ii / 2c-iii) stay in the working tree. Stash only this ticket's edited files with a pathspec (-- <paths>), not a blanket git stash push -u, so each stash is exactly one ticket — clean to apply → review → delete in a git GUI (e.g. git Fork), with no stray file bundled in. New tracked files an implementation adds (e.g. a new operator) are tracked-diffs and show fine in the stash; include their paths too.

powershell
git stash push -m "ticket #<number>: <short title>" -- <file1> <file2>

After stashing, the tracked tree is back at clean main for the next code ticket. Plan files from earlier tickets may sit untracked in the tree — that's fine: the pathspec stash ignores them and they don't affect builds.

2e. Record the outcome

Track, per ticket: number, title, disposition (implemented / planned / not-actionable / build-failed→planned), stash marker, files touched, and a one-line note.

Step 3 — final report

After the queue is done, print a single summary table:

| # | Title | Disposition | Artifact | Files | Note |

Artifact = a stash@{…} marker for code, or the .agentic/Plans/Plan_*.md path for a plan.

Then:

  • Flag overlapping files — e.g. a plan that will later edit the same file a code stash already changed — and suggest an order (land the code stash first).
  • Remind the user how to review each kind:
    • Code stashes: git stash show -p stash@{n}; or git stash apply stash@{n}, review, commit.
    • Plan files: already in Local Changes / .agentic/Plans/ — read, commit the keepers, delete the rest. (No stash to pop — they're plain files.)
  • If Step 0 stashed their pre-run work as keep/before-ticket-run, remind them to pop it.

Optional arguments

  • Triage only (no edits): if the user asks to "just triage" / "dry run", do Steps 1–2b only — classify every ticket and print the table with the intended disposition, writing nothing and creating no stashes. Good for a first look before a real run.
  • Single ticket: if the user names a ticket number, process only that one.
  • Different column: pass -Status Todo (etc.) to the helper to work another column.

© tixl3d, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/process-tickets of tixl3d/tixl.

Open the folder on GitHubat commit 9ce9691

Compare with similar skills

TiXL Ticket Processor next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

TiXL Ticket Processor compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
TiXL Ticket Processor this skilltixl3d/tixl5.1k—~2.6kAutomated safety check: PassMIT
Codewhale Evidence-Based Issue Closercodewhale-hq/Codewhale41k—~1.2kAutomated safety check: PassMIT
Creating GitHub Issues From Web Researchjeremylongshore/tons-of-skills-marketplace2.8k—~981Automated safety check: PassMIT
Git Project Statusespennilsen/pi122—~4.4kAutomated safety check: NotesMIT
Contributor-First PR MergeHKUDS/OpenHarness16k1 repos~847Automated safety check: PassMIT
Create Pull Requestcline/cline70k1 repos~1.6kAutomated safety check: PassApache-2.0

Similar skills

  • Codewhale Evidence-Based Issue Closer

    codewhale-hq/Codewhale

    Closes a GitHub issue only after confirming the fix actually landed on the real branch with a path or commit citation, then posts a crediting thank-you comment.

    41k GitHub stars~1.2k tokensUpdated today
    DevelopmentAuto-check passed

  • Creating GitHub Issues From Web Research

    jeremylongshore/tons-of-skills-marketplace

    Execute this skill enhances AI assistant's ability to conduct web research and translate findings into actionable github issues.

    2.8k GitHub stars~981 tokensUpdated today
    DevelopmentAuto-check passed

  • Git Project Status

    espennilsen/pi

    Generate comprehensive status reports for git repositories. An agent skill from espennilsen/pi.

    122 GitHub stars~4.4k tokensUpdated 17 days ago
    DevelopmentAuto-check: notes

  • Contributor-First PR Merge

    HKUDS/OpenHarness

    Merges external GitHub pull requests while keeping the original author credited, and fixes conflicts after the merge instead of rewriting the contribution.

    16k GitHub starsUsed in 1 repo~847 tokens
    DevelopmentAuto-check passed

  • Create Pull Request

    cline/cline

    Opens a GitHub pull request from your current branch with the gh CLI, after reviewing the commits and diff and gathering the details the PR needs.

    70k GitHub starsUsed in 1 repo~1.6k tokens
    DevelopmentAuto-check passed

  • Release Bump

    jamiepine/voicebox

    Ends a release cycle by moving the Unreleased changelog notes under a dated version heading, bumping version files with bumpversion and tagging the commit.

    57k GitHub stars~1.1k tokensUpdated 2 days ago
    DevelopmentAuto-check passed

More from tixl3d/tixl

  • TiXL Video Operator Analysis

    tixl3d/tixl

    Turns transcribed TiXL tutorial videos into an exhaustive, timestamped list of every operator mention, feeding the documentation editor's deep-link index without touching the wiki or YouTube text.

    5.1k GitHub stars~4k tokensUpdated today
    Auto-check passed

  • Sentry Issue Fix Loop

    tixl3d/tixl

    Walks through open Sentry issues for the tooll3 project, latest first, proposing a fix for each and committing them one at a time with your review between.

    5.1k GitHub stars~2.1k tokensUpdated today
    Auto-check: notes

  • TiXL UI Topic Doc Writer

    tixl3d/tixl

    Fills in empty embedded help text for TiXL's UI topics by distilling the maintainer's own video explanations into short, user-facing doc entries.

    5.1k GitHub stars~952 tokensUpdated today
    Auto-check passed

  • TiXL Feature Review Stub

    tixl3d/tixl

    Review a TiXL feature or change set for elegance, naming, robustness (exceptions, null refs, initialization order, threading) and realtime performance…

    5.1k GitHub stars~198 tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about TiXL Ticket Processor

What does TiXL Ticket Processor do?

Works through the In progress column of the TiXL road-map board unattended, turning simple tickets into git stashes and writing plans for the rest under .agentic/Plans. The skill runs without asking questions across the In progress column of the TiXL road-map GitHub board.agentic/Plans/ for anything too involved to guess at.

When should I use TiXL Ticket Processor?

TiXL Ticket Processor fits situations like: working through the in-progress tickets on the TiXL board; batch-processing a backlog while you are away; producing plans for tickets too big to implement blindly.

How do I install TiXL Ticket Processor in Claude Code?

Run `npx skills add tixl3d/tixl --skill process-tickets -a claude-code`. Or copy the skill folder (.claude/skills/process-tickets in tixl3d/tixl) into .claude/skills/process-tickets in your project. Claude Code loads it when a task matches its description.

How do I install TiXL Ticket Processor in Codex?

Run `npx skills add tixl3d/tixl --skill process-tickets -a codex`. Or copy the skill folder (.claude/skills/process-tickets in tixl3d/tixl) into .agents/skills/process-tickets in your project. Codex loads it when a task matches its description.

Can I use TiXL Ticket Processor in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add tixl3d/tixl --skill process-tickets -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/process-tickets, .gemini/skills/process-tickets, .github/skills/process-tickets and .opencode/skills/process-tickets in your project.

What does TiXL Ticket Processor need to run?

Going by SKILL.md and its folder, TiXL Ticket Processor needs the command-line tools its instructions call (git, dotnet and gh). Our summary lists: GitHub CLI with the read:project token scope; PowerShell, for Scripts/board-tickets.ps1; A TiXL checkout containing .agentic/AGENT_INSTRUCTIONS.md.

Does TiXL Ticket Processor access the network?

SKILL.md contains no URLs. Its commands use git and gh, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is TiXL Ticket Processor safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does TiXL Ticket Processor use?

TiXL Ticket Processor is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does TiXL Ticket Processor use?

About 2.6k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to TiXL Ticket Processor?

Skills that share tags, products or a category with TiXL Ticket Processor: Codewhale Evidence-Based Issue Closer (codewhale-hq/Codewhale, 41k stars), Creating GitHub Issues From Web Research (jeremylongshore/tons-of-skills-marketplace, 2.8k stars), Git Project Status (espennilsen/pi, 122 stars) and Contributor-First PR Merge (HKUDS/OpenHarness, 16k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains TiXL Ticket Processor?

tixl3d (a GitHub organization) maintains it in tixl3d/tixl, which has 5,130 GitHub stars. The repository holds 5 skills in this directory. The repository was last updated on October 8, 2026.

Source: tixl3d/tixl on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.