tiger

Guide developers in implementing fast, language-agnostic code with minimal overhead.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/bugabinga/pi-ext --skill tiger-bugabinga
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tiger
Source: https://github.com/bugabinga/pi-ext/tree/main/skills/tiger
Command: npx skills add https://github.com/bugabinga/pi-ext --skill tiger-bugabinga

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Tiger provides an ultra-minimal coding style guide that helps you produce fast, aggressive, language-agnostic implementations without unnecessary complexity.

Core Features & Use Cases

  • Speed-first structure: prioritize optimal algorithms, direct lookups, recursion over loops when appropriate, and caching for expensive operations.
  • Aggression with guardrails: pursue the goal directly with small responsibility blocks, explicit return values, and immediate error handling.
  • Caveman execution rules: minimize state, avoid comments and frameworks, reduce ambiguity, and simplify until it’s understandable.

Use it when you’re building performance-critical code, data pipelines, parsers/transforms, or any I/O-adjacent logic where clean, decisive control flow matters.

Quick Start

Apply the tiger rules to your next hot-path function by rewriting it with direct control flow, explicit early error handling, and the simplest data structures that fit.

Frequently Asked Questions about tiger

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I write faster, more aggressive code for performance-critical data pipelines?

Faster code requires prioritizing optimal algorithms, direct lookups, and caching for expensive operations. You should use small responsibility blocks, explicit return values, and immediate error handling to minimize overhead.

What is the best way to structure control flow for parsers and transforms?

The best way to structure control flow for parsers is using guard clauses for early returns and explicit error handling. This direct approach minimizes state and reduces ambiguity in performance-critical logic.

Can I use this minimalist coding style guide for any programming language?

Yes, this is a language-agnostic coding style guide. It focuses on universal execution rules like minimizing state, avoiding frameworks, and simplifying logic until it is understandable, regardless of the language.

When do I need to optimize data structures and algorithms in I/O-adjacent processing?

You need optimal data structures and algorithms in I/O-adjacent processing when building hot-path functions. Using the simplest structures that fit and recursion over loops when appropriate ensures decisive, fast execution.

Why does minimizing state and avoiding comments improve performance-critical code?

Minimizing state and avoiding comments forces aggressive, direct implementations with reduced ambiguity. This caveman execution approach simplifies logic until it is understandable, eliminating unnecessary complexity and overhead.