https://github.com/lossless-group/lossless-agent-skills

Pi & Agent-Skills-standard skills used by The Lossless Group. Starting with context-vigilance.
https://github.com/lossless-group/lossless-agent-skills

agent-skills agentic-engineering ai-skills context-engineering context-management context-vigilance pseudomonorepo

Last synced: 12 days ago
JSON representation

Pi & Agent-Skills-standard skills used by The Lossless Group. Starting with context-vigilance.

• Host: GitHub
• URL: https://github.com/lossless-group/lossless-agent-skills
• Owner: lossless-group
• License: mit
• Created: 2026-05-04T04:12:48.000Z (about 2 months ago)
• Default Branch: main
• Last Pushed: 2026-06-11T01:10:31.000Z (15 days ago)
• Last Synced: 2026-06-11T03:09:20.091Z (15 days ago)
• Topics: agent-skills, agentic-engineering, ai-skills, context-engineering, context-management, context-vigilance, pseudomonorepo
• Language: Astro
• Homepage:
• Size: 5.24 MB
• Stars: 4
• Watchers: 0
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • Changelog: changelog-conventions/SKILL.md
  • License: LICENSE

Awesome Lists containing this project

README

          
---

name: lossless-skills-readme

description: Overview of the Lossless Skills collection - installation instructions, skill status, and contributing guidelines. Reference only.

---

# Lossless Skills

The Lossless Group's agent skills collection — across projects and people.

A shared library of [Agent Skills](https://agentskills.io/specification) used by Lossless team members and AI coding agents on Lossless projects. Skills here are tool-agnostic: they work with [pi-coding-agent](https://github.com/badlogic/pi-mono), Claude Code, OpenAI Codex, and anything else that follows the Agent Skills standard.

## Built in public

This repo is part of [The Lossless Group's](https://www.lossless.group) **Lost in Public** practice: developing methods, tooling, and institutional knowledge openly so others can adopt, adapt, critique, and contribute. Expect frequent commits, occasional churn, and skills that evolve as the team's real workflows reveal what works.

If a skill here helps you, take it. If you find a sharper way to express it, open a PR. If you disagree with a convention, open an issue — we'd rather argue in public than silently diverge.

## Skills

| Skill | Directory | What it covers — and why we care |

|---|---|---|

| **Context Vigilance** | [`context-vigilance/`](./context-vigilance/) | Framework for managing `context-v/` directories — directory roles (specs / prompts / blueprints / reminders / explorations / issues), four-part `epoch.major.minor.patch` versioning, YAML frontmatter, wikilinks. AI co-development drowns in unstructured context; this is the team's working contribution to making thinking durable, retrievable, and version-aware across humans and agents. See . |

| **Pseudomonorepos** | [`pseudomonorepos/`](./pseudomonorepos/) | Coined Lossless pattern: parent repos that aggregate child repos (often submodules) primarily to host a parent-level `context-v/`. Encodes a *search-before-create* discipline and a tree-walking routine — without it, the same idea gets started in three places and the team loses to itself. |

| **Study Repos First** | [`study-repos-first/`](./study-repos-first/) | Discipline of pinning a curated collection of upstream repos (a *study*) around a domain question *before* designing or coding in that domain. Encodes "read upstream code, don't paraphrase from training data" — agents reach for plausible-but-stale conventions when real prior art is one `cd` away. This enforces the search-first habit for conventions, schemas, and protocols, and the setup mechanics for a study (named question, pinned submodules, promote-when-grows). |

| **Astro Knots** | [`astro-knots/`](./astro-knots/) | Tech hierarchy (HTML / CSS first, then vanilla JS, then a small package, then a framework), approved frameworks (Astro, Svelte, GSAP, Reveal), and hard prohibitions (React, JSX, Angular) for the family of ~10+ Astro sites. Without it, agents reach for `npm install` reflexively and the sites drift toward generic React-shaped JAMstack. See . |

| **Changelog Conventions** | [`changelog-conventions/`](./changelog-conventions/) | How to write `changelog/` entries — frontmatter (`publish: true`, `lede`, ISO dates), `YYYY-MM-DD_NN.md` filenames, `releases/` subfolder for product-style projects, show-don't-enforce ethos. "Changelog First Development" is the team's working theory: a fast-moving public changelog signals momentum to clients, contributors, and your future self. |

| **Git Conventions** | [`git-conventions/`](./git-conventions/) | Commit message conventions — structured headers with action verbs and effort groupings, paragraph-spaced bodies that explain impact before implementation, "Also included" riders for minor changes. Conventional Commits is too narrow; this captures both the change and the reason in a way that reads sensibly a year later. The same four-audience cascade `changelog-conventions` codifies for README / changelog / release narratives applies here: commit messages surface publicly via the GitHub commits view and the parent pseudomonorepo's rolled-up feed, so the header lands for the general audience and the body tail carries SHAs and Co-Authored-By for the internal team. |

| **gh CLI · Projects & Tasks Conventions** | [`gh-cli-projects-tasks-conventions/`](./gh-cli-projects-tasks-conventions/) | How the team uses `gh project` (GitHub Projects v2) to manage tasks across the pseudomonorepo tree. Premature on purpose — only two conventions exist today, codified now so they don't drift while the rest emerge: (1) compose with `pseudomonorepos` to resolve the repo a context-v file actually lives in (a path in the parent monorepo's working tree may belong to a submodule on GitHub, and a parent-monorepo URL 404s); (2) task bodies that reference `context-v/` files are *primarily the clickable GitHub URL* to the file in its own repo on the right branch tier, not a paraphrased summary. Ships a shell recipe for building the URL correctly plus `item-create` / `item-edit` / bulk-from-spec / field-edit examples. Open seams (status discipline, priority discipline, project layout, custom fields) are listed for fill-in as use cases write them. |

| **Theme System** | [`theme-system/`](./theme-system/) | Theme and mode architecture for Astro Knots sites: two-tier token system, three-mode contract (light / dark / vibrant), `theme.css` organization, design-system conventions. Without a shared system every site re-invents tokens, and mode toggles break in ways that are hard to debug after the fact. |

| **Maintain DESIGN.md** | [`maintain-design-md/`](./maintain-design-md/) | How to author and maintain a `DESIGN.md` file at the project root following [Google Stitch's open spec](https://github.com/google-labs-code/design.md) — frontmatter token groups (colors, typography, rounded, spacing, components) plus the eight canonical prose sections, the maintenance triggers (what code changes should bounce back into the doc), the runtime-CSS-is-source-of-truth discipline, and the precedent for off-spec extensions like the `imagery:` block. The agent-readable contract for a project's visual identity. Composes with `theme-system` (architecture) and `generate-consistent-og-images` (which reads the `imagery:` extension). |

| **Deck Iteration Workflow** | [`deck-iteration-workflow/`](./deck-iteration-workflow/) | Workflow for slides-only Astro sites (fundraise decks, conference talks): variant management, structured iteration cycle, alignment with the `calmstorm-decks` project patterns. Decks rot fast and agents over-engineer them; this keeps generation cheap and revision discipline tight when timelines are real. |

| **Crawl, Fetch, Ingest** | [`crawl-fetch-ingest/`](./crawl-fetch-ingest/) | The team's workflow for filling in team and portfolio metadata for VC firms and the operating companies they back: crawl a firm's site, fetch structured data + brand assets for people and companies referenced in a deck/PDF, ingest as canonical `.md` files with YAML frontmatter. Supports two starting anchors — **firm-anchored** (one VC → its team → its portfolio → portco CEOs) and **company-anchored** (one operating company → its backer firms → each backer's team + portfolio, stopping there) via the [`investor-credibility-ingest`](./crawl-fetch-ingest/routines/investor-credibility-ingest.md) routine, for fundraise-deck credibility cards. Encodes the four-checkpoint cascade, the cross-tool fallback pattern (Firecrawl → Tavily → OpenGraph.io), the global-cache-per-firm convention so the same firm's data is reused across multiple decks/memos. |

| **OpenGraph, Share, SEO & GEO** | [`open-graph-share-seo-geo/`](./open-graph-share-seo-geo/) | Rules for reliable share-preview unfurls in iMessage, WhatsApp, Slack, Discord, LinkedIn, X — plus traditional SEO and Generative Engine Optimization (GEO). Encodes the JPEG-over-WebP rule, the CDN-not-`/public` rule, and the ImageKit content-negotiation gotcha (`og:image:type` must match the bytes the unfurler actually receives, not the URL extension) that cost us a debugging cycle. |

| **Generate Consistent OG Images** | [`generate-consistent-og-images/`](./generate-consistent-og-images/) | How to generate share-imagery (banners, portraits, squares, tall WhatsApp/iMessage cards) for any Lossless site so the resulting images form a coherent visual family. Locks every parameter on the Ideogram v3 request except `prompt` and `aspect_ratio`; the rest (style reference, color palette weights, negative prompt, seed, rendering speed) lives in the project's `DESIGN.md` `imagery:` block. Encodes the empty-space-as-first-class-subject prompt structure (lead with the empty region, give it concrete content, then put the subject in the second clause) that defeats the "subject grows up into the SVG overlay zone" failure mode. WhatsApp / iMessage chat-preview is the primary target. |

| **Lossless Flavored Markdown** | [`lossless-flavored-markdown/`](./lossless-flavored-markdown/) | Polyglot extended-markdown spec — user-configured *syntax-triggers* drive a render pipeline in a frontend framework, giving plain `.md` files MDX-class power without MDX's JSX-shaped lock-in. Implemented as `@lossless-group/lfm` on [JSR](https://jsr.io); source lives in `astro-knots/`. Use when authoring or rendering content, building components routed from markdown, or co-developing the package itself. |

| **Maintain Splash Pages** *(Draft)* | [`maintain-splash-pages/`](./maintain-splash-pages/) | The repo-level splash pattern: small Astro sites at `/splash/` that ship to GitHub Pages on push to `main`, render the repo's `changelog/` + `context-v/` alongside curated marketing copy, and stay isolated from any package the repo also publishes. Codifies the proven shape across three reference implementations (`memopop-site`, `content-farm/splash`, `lfm/splash`) and the package-isolation discipline that keeps splashes safe to add to repos that also publish to JSR / npm. |

| **Maintain Filemap** *(loop)* | [`maintain-filemap/`](./maintain-filemap/) | Loop discipline for keeping a `FILEMAP.md` at the root of each Lossless repo current with the actual on-disk tree. Each FILEMAP has two parts: a hand-authored **curator preface** (what each top-level directory IS — purpose, ownership, conventions; edited rarely) and a **generated `tree -L 3` block** spliced between `` / `` sentinels (regenerated by the loop's script every time the discipline fires). Fires on three triggers: directory-shape changes as-it-happens (new top-level dir, submodule mount/unmount, major subsystem rename), weekly cadence, and pre-release. Why both halves: a raw `tree` dump doesn't tell a newcomer *what they're looking at* — the curator preface is what makes the file legible, the generated tree is what makes it accurate. Composes with `pseudomonorepos` (parent FILEMAP stops at submodule mounts at depth 3; each submodule carries its own). |

| **Chroma Agent Skills** *(submodule)* | [`chroma-agent-skills/`](./chroma-agent-skills/) | Official skills from the [Chroma](https://www.trychroma.com) team for integrating Chroma local and Chroma Cloud (CloudClient, schema, hybrid search, cloud CLI). Pinned as a git submodule from [`chroma-core/agent-skills`](https://github.com/chroma-core/agent-skills); we vendor it here so any agent loading the Lossless skills tree gets battle-tested vector-store guidance from upstream rather than paraphrased-from-training-data Chroma usage. |

| **Market Capture Analysis** | [`market-capture-analysis/`](./market-capture-analysis/) | Answers the first of the two foundational VC questions — *how big can it get?* — by walking revenue and EBITDA across an 8-step penetration grid (`1%, 3%, 5%, 10%, 25%, 35%, 50%, 60%`) for SAM / SOM / TAM at the company's existing pricing and business model. A static if-then picture: the size of the prize at each penetration step with every assumption named so the reader can react to it. Encodes the failure modes (silently picking the optimistic cell, training-data margin assumptions, conflating "unit of sale" with "customer") and the synthesis discipline (3–5 cells in the memo, one named base case, market definition anchored explicitly). Pairs with the sibling skill [`timeline-scenario-analysis`](./timeline-scenario-analysis/), which answers *how fast?* — running this skill alone produces a destination with no route. |

| **Timeline Scenario Analysis** | [`timeline-scenario-analysis/`](./timeline-scenario-analysis/) | Answers the second of the two foundational VC questions — *how fast can it get that big?* — by stress-testing the company's current MoM/YoY growth at its actual unit of sale across four scenarios (`sustain` / `improve` / `plateau` / `reduce`). Operates on the penetration grid produced by [`market-capture-analysis`](./market-capture-analysis/); sensitivity tables show what it takes to reach each cell and how time-to-base-case shifts with small growth-rate changes. Encodes the failure modes (compounding a recent spike forever, hiding recent deceleration behind YoY, omitting the plateau scenario, skipping the base-case time-to-reach number — that last one is the single most useful sentence the skill produces). Pairs with [`market-capture-analysis`](./market-capture-analysis/); running this alone produces a growth curve aimed at nothing in particular. |

| **Competitive Analysis** | [`competitive-analysis/`](./competitive-analysis/) | Reference taxonomy for classifying competitors in an investment-memo competitive landscape section. Two orthogonal axes — **stage ring** (concentric circles outward from the target's own stage: `early stage` / `early scaleup` / `scaleup` / `mezzanine` / `incumbents`) and **competitor type** (`direct` / `adjacent` / `indirect` / `noisewashing`). Every competitor tagged on both. Encodes the noisewashing-vs-genuine-threat test (coverage doesn't discriminate, but paying users + multi-year capex + earnings-call segment reporting does), the discipline of preferring the looser classification on boundaries (most "direct" candidates are really `adjacent`), and the exhaustive-vs-synthesized two-artifact pattern shared with the two memo skills above — long classified research file + scannable memo section with a table, grouped list, or ring diagram. |

| **Search Lossless Corpus** | [`search-lossless-corpus/`](./search-lossless-corpus/) | The discipline of querying The Lossless Group's local Chroma database — populated by [`context-vigilance-kit`](https://github.com/lossless-group/lossless-ai-labs/tree/main/context-vigilance-kit) with four collections (`context-vigilance-corpus`, `lossless-changelog`, `claude-code-sessions`, `claude-code-tool-traces`) — before answering questions prior work might already have answered. Encodes the four-step agentic-search loop (decompose → execute → evaluate → synthesize), the five canonical question shapes that trigger retrieval ("what did we decide / when did we ship / why did we choose / has this failed / where did we put"), the metadata-filter patterns that keep queries precise, and the citation discipline (every claim cites `source_path` + timestamp + `source_repo_slug`). Lossless layer on top of the upstream `chroma-local` / `chroma-cloud` skills — without it the corpus sits there full of high-signal records nobody queries; with it, every "what did we decide about X" becomes grounded recall the user can verify in seconds. |

**Planned / not yet shipped:** `lossless-loop/` — the 5-phase Start → Progress → Reflect → Publish → Market lifecycle for any meaningful unit of work. Diagram and spec live at `pseudomonorepos/references/lifecycle-workflow.md` until the skill graduates.

A running backlog of additional candidates lives in [**`CANDIDATES.md`**](./CANDIDATES.md).

## Engineer-influencer collections we watch

External skills repos from engineer-influencers in the broader community. We track them for inspiration and to see where conventions converge. These are not pinned references — just repos whose evolution we follow.

| Engineer | Repo | Known for |

|---|---|---|

| **Matt Pocock** | [mattpocock/skills](https://github.com/mattpocock/skills) | TypeScript educator and engineer (Total TypeScript, `ts-reset`). |

## Install

### Pi (recommended for Lossless contributors)

```bash

pi install git:github.com/lossless-group/lossless-skills

```

Or clone directly into the global skills directory:

```bash

git clone https://github.com/lossless-group/lossless-skills.git ~/.pi/agent/skills

```

In an active pi session, run `/reload` to pick up changes without restarting.

### Claude Code

Clone into Claude's skills directory:

```bash

git clone https://github.com/lossless-group/lossless-skills.git ~/.claude/skills

```

### OpenAI Codex / other harnesses

Clone anywhere and point your tool's skills configuration at the directory.

### Cross-tool sharing on one machine

Use the `~/.agents/skills/` location (read by pi and other Agent-Skills-compatible tools), or symlink:

```bash

ln -s ~/.pi/agent/skills ~/.agents/skills

```

## Layout

Each skill is a directory with a `SKILL.md` file:

```

/

├── SKILL.md              # Required: frontmatter (name, description) + instructions

├── references/           # Deep-dive docs the agent loads on demand

├── templates/            # Scaffolds for new files

└── scripts/              # Helper scripts (when needed)

```

The `description` in `SKILL.md` frontmatter determines when an agent will auto-load the skill. Be specific.

## Contributing

Skills here represent shared Lossless conventions. Before adding or changing a skill:

1. **Discuss first** if it changes how the team works (open an issue or a draft PR with rationale).

2. **Match existing conventions:**

   - Skill directory and `name:` field: lowercase with hyphens (e.g., `context-vigilance`)

   - Filenames inside skills: `Train-Case.md`

   - Frontmatter follows the Agent Skills spec

3. **Test the skill** in a real session before committing — verify the agent loads it when you'd expect.

4. **Commit message convention:**

   ```

   skill(): short description

   ```

### Adding a new skill

1. `mkdir ` (lowercase, hyphens, must match `name:` in frontmatter)

2. Create `SKILL.md`:

   ```yaml

   ---

   name: 

   description: When the agent should load this skill. Be specific about triggers.

   ---

   ```

3. Add `references/`, `templates/`, `scripts/` as needed

4. Update the **Skills** table in this README

5. Open a PR

## References

- [Agent Skills Specification](https://agentskills.io/specification)

- [pi skills documentation](https://github.com/badlogic/pi-mono/blob/main/packages/pi-coding-agent/docs/skills.md)

- [Context Vigilance project](https://www.lossless.group/projects/gallery/context-vigilance)

- [The Lossless Group](https://www.lossless.group)

## License

[MIT](./LICENSE) © The Lossless Group