Siftable Skills

Siftable Skills is a collection of 62 skills for engineering, design, planning, and writing. Tometo Mode is the main entry point: it reads the project, selects the relevant skills, and carries an authorized change through verification.

Use Tometo to coordinate substantial engineering work, or invoke an individual skill for a narrower job such as investigating a regression, reviewing an interface, or editing prose.

Each skill is a folder with a SKILL.md entrypoint and any references or helpers it needs. The installer follows links between sibling skills, so selecting a workflow brings its dependencies with it. You can install the library outside your application repository.

I believe that while frontier models are extremely capable, they often still revert to the mean of development practices rather than the very best practices. That's why I use language and framework specific skills to eke out performance gains wherever the agents work, to steer the models towards excellence.

Install Tometo Mode

Use your existing coding agent, Python 3, and a reviewed checkout of this repository. Set the destination to a directory your agent discovers; $HOME/.agents/skills is one common choice.

# Preview Tometo Mode and its dependencies.
python3 scripts/install_skills.py --destination "$HOME/.agents/skills" \
  --skill tometo-mode

# Apply the same selection.
python3 scripts/install_skills.py --destination "$HOME/.agents/skills" \
  --skill tometo-mode --apply

This installs Tometo's workflow, references, helpers, and linked specialty skills, including language and WebAssembly guidance. Start a fresh agent task and ask:

Use $tometo-mode to implement this feature and verify it through the real user path.

Check that the agent reads the skill. Files on disk establish installation; discovery depends on your agent and its configuration.

For the whole collection, omit --skill tometo-mode. For a focused task, select a skill with --skill NAME; repeat the flag to combine skills. The engineering and languages profiles offer grouped selections. Every selection includes its declared dependencies.

What Tometo does

Tometo gives substantial work a consistent shape: understand the promise, inspect the code, choose the right method, implement within scope, and check the result at the boundary the user will use. A passing unit test supports a narrower claim than a verified user journey. The final report should make that difference clear.

The main routes are:

Need	Skill
Find the cause of a regression	pstack-investigate
Choose languages, frameworks, runtimes, or boundaries	architecture-selection
Decide interfaces and ownership	pstack-architect
Review a diff	pstack-interrogate
Exercise changed behavior	pstack-verify
Make a verification recipe reusable	pstack-create-verification-skill
Learn a mechanism from another codebase	repo-learn
Improve interactions or challenge a layout	emil-design-eng and break-ui
Build and check language-specific changes	The matching language skill, selected from the project's files and toolchain
Integrate WebAssembly with a browser, WASI, or another host	wasm plus the source-language skill

The Tometo entrypoint also routes task framing, catch-up reports, relevant language guidance, and optional formal or recurring-work checks. Those references load when the task needs them. A small fix can stay small.

You can ask for a narrower procedure directly:

Use $rust to diagnose this lifetime issue with the repository's pinned toolchain.
Use $break-ui to stress-test this component with plausible worst-case data.
Use $repo-learn to compare recovery mechanisms before we choose one for this project.

The skill guide explains how to choose, combine, document, and maintain skills, including a repo-learn example.

Installation and updates

The installer reads a local checkout and uses Python's standard library. It stages complete packages, checks their contents and executable bits, and records hashes in .siftable-skills.json in the destination.

To refresh an installation, repeat its selection from your reviewed checkout:

python3 scripts/install_skills.py --destination "$HOME/.agents/skills" \
  --skill tometo-mode --apply --update

Updates replace only unchanged packages this installer already manages. It refuses unmanaged conflicts, local modifications, and symlink paths. Repeating the same installation is idempotent. Changing a selection leaves previously installed skills in place.

If an update is interrupted, preserve the transaction and follow the recovery procedure. Packages installed by the earlier ZIP method are unmanaged; review them or choose an empty destination before migrating.

For cloud agents, follow Cloud setup and Cloud startup instructions. Pin a reviewed commit in both setup and maintenance, then test discovery in a fresh task. Updating this repository does not change an existing cloud environment's pin.

Tools and permissions

The Tometo installation supplies the workflow and its skill dependencies. Compilers, browsers, native apps, MCP servers, provider CLIs, worker engines, and credentials come from your environment and are needed only for the tasks that use them.

Browser and native-app work needs an available observation and action tool. Supervised workflows need a compatible, separately configured engine. Corpus retrieval needs an authorized backend and source collection. PDF, transcription, and Sentry workflows use the available document or service route. Each skill explains its requirements and reports missing capabilities.

The task still determines what the agent may do. Installing a skill grants no authority to deploy, delete data, send messages, publish, or spend money. Verification should name the artifact checked and the behavior observed; an unavailable integration remains unverified.

Maintain the library

python3 scripts/validate_repo.py
python3 scripts/run_tests.py

Validation checks package metadata, resource links, symlinks, personal paths, excluded personal workflows, and likely secrets. Tests cover helpers, installer conflicts and recovery, offline cloud setup, and clean installations with only the declared dependencies. Filesystem mutation tests use disposable fixtures. Live provider, browser, cloud, and native-app behavior needs its own checks.

See the authoring guide before changing a package. Keep the procedure in the skill, conditional detail in references, and provenance in skill-sources.json. The current refresh preserves reviewed public adapters and tested helpers where local sources contain private data or depend on a particular runtime.

Personal and project-specific workflows, material sourced through personal-workflow collections, private corpora, credentials, local binaries, and repository overlays are excluded. Source and license attribution stays with the packages.

All skills

62 skill packages are included.

Skill	Scope
architecture-selection	Workload-grounded stack and execution design decisions
autoplan	Compatibility route to Tometo Mode
aws-secrets-manager	Opaque runtime secret integration and metadata-only diagnosis
break-ui	Schema-backed UI data, layout, and edge-state stress testing
c-systems-programming	C file I/O, processes, signals, and operating-system interfaces
cloud-environment-runtime	Cloud execution, network, credential, and persistence context
colophon	Local voice-profile discovery, verified prompt export, and Markdown candidate checks
cpp	C++ ownership, errors, concurrency, templates, native ABI, and build verification
css	CSS, Tailwind, cascade, layouts, and computed styles
emil-design-eng	Frontend interaction, motion, accessibility, and performance
filesystem-lifecycle	Evidence-based storage audits and guarded filesystem cleanup
footwork-tools	Observation and action routes for browsers, apps, services, and artifacts
generating-design-references	Design-reference generation through an approved image tool
gh-fix-ci	GitHub Actions failure investigation and bounded remediation
gis-spatial-analysis	Deterministic GIS, QGIS, cartography, and web-map workflows
go	Go implementation, review, modules, toolchains, and validation
grok-guide	Explicit Grok planning, replanning, and completion-audit integration
human-writing	Public prose with factual, source, voice, and text-hygiene checks
investigate	Compatibility route to pstack investigation
kotlin	Kotlin APIs, coroutines, Gradle, Android, and multiplatform work
linux	Kernel, userspace, services, and desktop integration
mermaid	Mermaid diagram rendering through the selected available route
opengl-c-graphics	Core-profile OpenGL in C, shaders, buffers, and GPU diagnosis
paper-design	Paper design inspection, editing, export, and handoff
pdf	PDF extraction, creation, manipulation, rendering, and verification
pgvector-postgres	PostgreSQL vector search, plans, recall, indexes, and migrations
plan	Evidence-grounded plans and visual sequencing
plan-eng-review	Compatibility route to pstack architecture review
playwright	Browser automation through the configured Playwright route
predict-future	Scoreable probabilistic forecasts and decision update triggers
pstack-architect	Interfaces, ownership, module boundaries, and executable change plans
pstack-create-verification-skill	Project-local verification harness creation and execution
pstack-interrogate	Independent diff scrutiny, traceable findings, and review verdicts
pstack-investigate	Defect reproduction, competing causes, and bounded verified fixes
pstack-maintain-verification-skill	Verification harness audits against source and live behavior
pstack-verify	Verification on real apps, CLIs, services, or artifacts
react-best-practices	React and Next.js rendering, hooks, bundles, and measured performance
repo-learn	Source-grounded engineering patterns and explicit evidence stores
review	Compatibility route to pstack independent review
rust	Rust ownership, errors, async, unsafe/FFI, toolchains, and Cargo gates
screenshot	Scoped desktop, app, window, and region capture
search-local-corpus	Backend-neutral retrieval with source locators and citations
searching-design-corpus	Specialized design and systems corpus retrieval through an adapter
semantic-density	Precise internal notes, prompts, and model-facing instructions
sentry	Read-only issue and event investigation through configured access
sharp-edit	Concise business writing with preserved facts, certainty, and voice
soc2-compliance	SOC 2 scope, controls, evidence, readiness, and gap assessment
strategic-decision-mapping	Actors, incentives, moves, countermoves, and next decisions
supervise	Compatibility route to supervised coding
supervise-fable	Fable planning/review with isolated implementation workers
supervise-kimi	Kimi design implementation with independent supervised review
supervise-opus	Opus planning/review with isolated implementation workers
supervise-workflow	Supervised workflow contracts, worker isolation, verification, and recovery
swift	Swift APIs, concurrency, Apple UI, native interop, SwiftPM, and Xcode verification
teach	Concept and skill teaching grounded in the current workspace
terraform-gcp	Google Cloud Terraform/OpenTofu, IAM, state, services, and verification
thinking-scientific-method	Falsifiable hypotheses, predictions, tests, and revision
tometo-mode	Coordinated engineering with specialty skills and executable verification
transcribe	Audio/video transcription with timestamps and optional speaker labels
typescript	TypeScript types, compiler behavior, modules, and build/test gates
wasm	WebAssembly artifacts, browser bindings, WASI components, and host verification
zig	Version-aware Zig APIs, allocation, I/O, FFI, and measured optimization

Source and license

Maintained by Thomas Main. See the MIT License, third-party notices, and source records for the origin and terms of adapted material. As the name Tometo mode suggests, the basic way it works is heavily based on Poteto mode by Lauren Tan and her skills work.