Loogacy agent skills

This repository stores reusable agent skills, repo level benchmark workflow material, and plugin bundles for coding agents.

The current focus is practical agent work around Godot, .NET, C#, benchmark authoring, and game development patterns that can stay portable across more than one engine.

For the broader skill format and ecosystem, see agentskills.io.

Note

This repo is not a gameplay library, engine addon, or NuGet package. It is a source repository for skill instructions, references, templates, benchmark assets, and workers that belong to a specific plugin.

Start here

Use the repo straight from source.

1. Make the repository available to your agent runtime.
2. Expose the skill folders under .agents/skills/, .github/skills/, and plugins/*/skills/.
3. If your runtime supports internal workers, also expose .github/agents/ and plugins/*/agents/.
4. Start from the section below that matches the work you are doing.

If you only need one rule of thumb: use a direct skill when one focused artifact is enough, and use an internal worker when the task is genuinely mixed and benefits from tighter context boundaries.

What lives in this repo

The repo has six main surfaces.

Area	What it holds	Start here
.agents/skills/	Authoring skills for the whole repo: creating skills, splitting work into subagents, grilling plans, and session handoff	Core authoring skills
.github/skills/	Shared benchmark and eval workflow skills	Repo benchmark skills
.github/agents/	Benchmark orchestration workers for the whole repo	Repo benchmark workers
evals/godot-dotnet/	The canonical repo local corpus for the godot-dotnet benchmark and evaluation flow	evals/godot-dotnet/README.md
plugins/godot-dotnet/	Godot and .NET implementation, review, validation, and upgrade guidance	plugins/godot-dotnet/README.md
plugins/game-development/	Portable game development patterns that are not tied to one engine family	plugins/game-development/README.md

There is also a practical fixture layer under tests/ for hands on plugin trials in tracked Godot projects.

Core authoring skills

These are the skills you use when you are building or improving the agent system itself.

Skill	Use when	Main output
create-reusable-skill	You want to create a new skill or tighten up an existing one without overbuilding it.	A right sized skill structure, drafted SKILL.md, and support files only when they are justified.
create-subagent	You need to decide whether a task should stay single agent or be split into a bounded subagent topology.	A recommendation state, topology blueprint, subagent specs, shared state plan, and evaluation checklist.
plan-design-grill	You want a plan or architecture pushed until its assumptions and branch choices are explicit.	A grill summary with resolved decisions, open branches, and recommended next steps.
session-handoff	Work needs to continue in a later session or a fresh agent.	A continuation ready handoff package with verified state and exact next steps.

Repo benchmark skills

These sit above the godot-dotnet corpus and below full orchestration.

If you want the corpus index first, start from evals/README.md.

Skill	Use when	Main output
benchmark-core	You need the shared benchmark framework rules before choosing a narrower route.	Capability, corpus discovery, lifecycle, and portability guidance.
benchmark-author-item	You want to turn a benchmark idea into the repo's canonical item format.	A reusable benchmark item draft with route, artifact, scoring, and variant hooks.
benchmark-author-rerun-manifest	You need a bounded rerun slice for a candidate revision.	A rerun manifest ready for offline execution and judging.
benchmark-judge-run	You want to convert an execution result into the canonical judged format.	A scored run record with failure tags and invariance or robustness notes.
benchmark-review-candidate	You want to review whether a candidate revision should be promoted.	A candidate review record with an explicit promotion decision.
benchmark-author-variants	You want metamorphic or adversarial variant packs from the shared family catalog.	A reusable variant_bundle with invariants, drift budget, and transformed inputs.
benchmark-cluster-failures	You want repeated judged failures grouped into reusable patterns.	A canonical failure cluster record with actionable weakness framing.

Repo benchmark workers

These workers live under .github/agents/ and handle multi stage benchmark work.

Agent	Use when	Main output
benchmark-director	You want one coordinator to run a benchmark cycle end to end.	A consolidated benchmark coordination package with phase and suite status.
benchmark-item-runner	You want to execute one benchmark item across baseline, skill, and or worker paths.	A per path execution record for downstream judging or variant work.
suite-judge	You want an independent route first judge for an execution package or variant run.	A judged run package with rubric scores, failure tags, and invariance or robustness notes.
variant-lab	You want metamorphic or adversarial stress variants authored and packaged for rerun.	A variant_bundle with explicit families, invariants, and transformed inputs.
failure-clusterer	You want repeated judged failures grouped into reusable failure clusters.	A failure_cluster_report with repeated weakness framing and next step guidance.
candidate-proposer	You want a bounded wording, routing, rubric, or template candidate proposed from clustered evidence.	A candidate_revision package prepared for rerun planning.
promotion-gatekeeper	You want the final promotion decision grounded in gain, regressions, invariance, robustness, and governance checks.	A promotion_decision package with explicit gate reasoning.

Plugin catalog

The plugin layer is the market facing part of this repository.

Plugin	Focus	Current shape	Start here
godot-dotnet	Godot 4.6, .NET 10, C#, .tscn, review, validation, and upgrade planning	10 reusable skills, 3 internal workers	plugins/godot-dotnet/README.md
game-development	Portable game development patterns across engines, with the current 3 + 2 + 2 shared-semantics rollout plus higher-level behavior and flow skills	16 reusable skills, no internal workers yet	plugins/game-development/README.md

Quick picks from godot-dotnet

• C# implementation or refactor work → godot-csharp
• Direct scene file work → godot-tscn
• GoDotTest setup or runtime test coverage → godot-godottest
• First pass runtime diagnosis → runtime-triage
• Mixed architecture and UX review → design-reviewer
• Upgrade planning with rollback and validation structure → migration-quality-planner

Quick picks from game-development

• Reusable condition semantics and rule ownership → game-development-condition-rule-engine
• Shared cost, reservation, refund, and commit rules → game-development-resource-transaction-system
• Cooldowns, timers, and reevaluation cadence → game-development-time-source-and-tick-policy
• Blackboard facts, freshness, and planner-readable truth → game-development-world-state-facts
• Identity handles, stale references, and lifetime boundaries → game-development-entity-reference-boundary
• Tag taxonomy, filtering, and declarative queries → game-development-gameplay-tags-and-query
• Diff vs snapshot payloads, invalidation, and notification batching → game-development-state-change-notification
• First route choice across FSM / behavior tree / Utility AI / GOAP → game-development-behavior-architecture
• Spawn and despawn churn, pooling, or GC spike work → game-development-object-pool

Where to start by task

If you already know what kind of work you are doing, use this map.

I need to...	Open this first
Create or improve a reusable skill	.agents/skills/create-reusable-skill/
Decide whether a task should be split into subagents	.agents/skills/create-subagent/
Stress test a plan or architecture before implementation	.agents/skills/plan-design-grill/
Continue work in a fresh session	.agents/skills/session-handoff/
Work on benchmark framework rules or routing	.github/skills/benchmark-core/
Work on the canonical eval corpus	evals/godot-dotnet/README.md
Use Godot and .NET implementation or review skills	plugins/godot-dotnet/README.md
Use cross engine gameplay and architecture patterns	plugins/game-development/README.md
Run practical fixture trials in tracked projects	tests/README.md

Repository layout

.agents/
└── skills/                 # repo wide authoring skills

.github/
├── agents/                 # repo level benchmark workers
└── skills/                 # repo shared benchmark workflow skills

evals/
└── godot-dotnet/           # canonical repo local corpus for godot-dotnet

plugins/
├── game-development/
│   ├── plugin.json
│   ├── README.md
│   ├── agents/
│   └── skills/
└── godot-dotnet/
    ├── plugin.json
    ├── README.md
    ├── agents/
    └── skills/

tests/
├── plugin-snapshots/       # shared staging copies for fixture trials
├── runs/                   # generated working copies, gitignored
├── scripts/                # trial automation helpers
└── <FixtureName>/          # tracked template projects

Inside a typical skill folder you will usually see:

• SKILL.md for the main workflow and triggering guidance
• references/ for reusable heuristics and checklists
• assets/ for templates, examples, or output skeletons

Adding new material

Keep the split clean when you add or move content.

• Put repo wide authoring skills under .agents/skills/
• Put shared benchmark workflow skills under .github/skills/
• Put repo level benchmark workers under .github/agents/
• Put benchmark corpora and run evidence outside plugins/
• Put market facing plugin material under plugins/<plugin-name>/

For plugins in particular, keep the long term shipped surface limited to:

• plugin.json
• README.md
• agents/
• skills/

License

See LICENSE for details.