ai-developer-skill-os 3.1.4 → 5.0.0

package/taste-skill/research/laziness/findings/references.md

@@ -0,0 +1,20 @@
+# References
+
+## Cited Studies
+
+- **EmotionPrompt (Microsoft Research)** — Demonstrates that emotional and stakes-based prompt framing mathematically improves LLM reasoning quality and output length. Documents the +45% improvement from financial framing and +115% from combined stimuli.
+
+- **LazyBench** — Proves that frontier models (Gemini 1.5 Pro, GPT-4o) actively select cognitive shortcuts and fail tasks they are capable of solving when the perceived effort exceeds internal thresholds.
+
+- **Compounding Error Avoidance** — Research demonstrating that models truncate outputs as a risk mitigation strategy, preferring shorter responses to reduce the surface area for factual errors on long-form tasks.
+
+- **Seasonal Behavior Analysis (Winter Break Hypothesis)** — Statistical analysis confirming that LLMs internalize seasonal work patterns from training data, producing measurably shorter outputs during periods corresponding to human holiday seasons.
+
+- **2025 Controlled Laziness Experiments** — Three-part academic study (December 2025) confirming that output truncation is a behavioral artifact of alignment training, not a failure of context processing or model capability.
+
+## Further Reading
+
+- Google Gemini API documentation on `thinking_level` parameter configuration
+- Anthropic MCP (Model Context Protocol) specification and integration guides
+- OpenAI API reference for temperature and Top-p parameter tuning
+- YAML front-matter specification for SKILL.md lazy-loading architecture

package/taste-skill/research/laziness/remediation/architectural-patterns.md

@@ -0,0 +1,55 @@
+# Architectural Patterns
+
+## Lazy-Loaded Skills
+
+The standard pattern for managing large context requirements across AI agents is lazy-loaded prompt engineering through skill files.
+
+A skill is a folder containing a `SKILL.md` file with:
+
+- **YAML front-matter:** Contains `name` and a precise `description`. This metadata acts as the discovery hook — the agent reads only this during initialization (~100 tokens per skill).
+- **Markdown body:** Full workflows, rules, and instructions. Loaded on-demand only when the agent determines the skill is relevant.
+
+This architecture yields a documented 35% reduction in average context usage and prevents context dilution. However, discovery reliability depends on the specificity of the YAML description:
+
+| Description Quality | Discovery Success Rate |
+|:---|:---:|
+| Vague ("Helps with designing APIs") | ~68% |
+| Specific ("Design RESTful HTTP APIs with OpenAPI specs, focusing on versioning, error codes, and backward compatibility") | ~90% |
+
+## Model Context Protocol (MCP)
+
+MCP is an open standard (pioneered by Anthropic, adopted by Google and OpenAI) that enables real-time, bidirectional connections between LLMs and external data sources.
+
+### Architecture Components
+
+- **Host:** The AI application (IDE, terminal tool, chatbot) containing the LLM engine.
+- **Client:** Internal bridge within the host that handles protocol communication.
+- **Server:** External service exposing databases, APIs, or documentation to the client.
+- **Transport:** JSON-RPC 2.0 messages over stdio (local) or HTTP (remote).
+
+### How It Reduces Truncation
+
+Without MCP, models rely on static training weights for factual claims. When those weights are outdated (e.g., a new API version was released after training cutoff), the model either hallucinates a plausible answer or truncates its response to avoid committing to specifics.
+
+With MCP, the model fetches current documentation directly into its context window. This transforms the model from a static knowledge store into a reasoning engine operating on real-time data, eliminating the incentive to hallucinate or truncate.
+
+### Example: Developer Knowledge API
+
+Google's Developer Knowledge MCP Server indexes live documentation across Firebase, Android, and Google Cloud. When a model receives a development question:
+
+1. It executes a `search_document` query against the live index
+2. It evaluates returned page URIs
+3. It fetches full document content via `get_document` or `batch_get_documents`
+4. It generates its response based on current, authoritative documentation
+
+This entirely bypasses the tendency to fabricate answers from outdated training data.
+
+## Chunked Task Execution
+
+For complex tasks that would produce outputs exceeding the model's generation limit, break the work into sequential steps:
+
+1. Request the architecture and structure first (outline only)
+2. Request each component individually with explicit instructions for completeness
+3. Request assembly and integration after all components are generated
+
+This prevents the model from attempting to estimate total output length and preemptively compressing its response.

package/taste-skill/research/laziness/remediation/parameter-tuning.md

@@ -0,0 +1,44 @@
+# Parameter Tuning
+
+## Temperature and Top-p
+
+Autoregressive models select each next token from a probability distribution generated by a softmax function applied to logit values. When a model defaults to brief outputs, the tokens associated with truncation and summarization have been assigned the highest probabilities through RLHF alignment.
+
+### Temperature
+
+Adjusting the temperature parameter changes how the softmax function distributes probability mass across candidate tokens.
+
+- **Low temperature (0.0 - 0.5):** Amplifies differences between high and low-probability tokens. The model becomes highly deterministic, consistently selecting the highest-confidence continuation. Optimal for code generation, data extraction, and structured output.
+- **Default temperature (1.0):** Retains the original probability distribution from training.
+- **High temperature (1.5+):** Flattens the distribution, introducing more randomness. Useful for creative tasks but increases the risk of incoherent outputs.
+
+Example probability distribution shift for a single token position:
+
+| Token Candidate | Probability at Temp 1.5 | Probability at Temp ~0.0 | Raw Logit |
+|:---|:---:|:---:|:---:|
+| lazy | 0.4875 | 0.9933 | 2.0 |
+| quick | 0.2503 | 0.0067 | 1.0 |
+| tired | 0.1285 | 0.0000 | 0.0 |
+| slow | 0.0660 | 0.0000 | -1.0 |
+| clumsy | 0.0339 | 0.0000 | -2.0 |
+
+### Top-p (Nucleus Sampling)
+
+Top-p truncates the probability distribution by only considering the smallest set of tokens whose cumulative probability exceeds threshold p. A Top-p of 0.0 to 0.6 combined with low temperature forces the model into a narrow, deterministic execution path, reducing the entropy that enables creative refusals and unnecessary summarization.
+
+## Gemini Thinking Level Configuration
+
+Google Gemini 3 models replaced the legacy `thinking_budget` (a hard token count cap on internal reasoning) with a `thinking_level` parameter that provides relative guidance on computational depth.
+
+| Setting | Flash Support | Pro Support | Use Case |
+|:---|:---:|:---:|:---|
+| `minimal` | Yes | No | High-throughput, low-latency tasks |
+| `low` | Yes | Yes | Simple instruction following, data extraction |
+| `medium` | Yes | Yes (3.1 Pro) | Moderate complexity tasks |
+| `high` | Yes (Default) | Yes (Default) | Complex analysis, code generation, mathematics |
+
+Important constraints:
+- `thinking_level` and `thinking_budget` are mutually exclusive. Using both in one API call triggers an HTTP 400 error.
+- Even at `low`, Gemini Pro models perform mandatory minimum internal deliberation for safety and alignment.
+- For code generation and complex analysis, set to `medium` or `high` for quality scores consistently exceeding 92-95% compared to baseline.
+- Avoid combining extremely low temperature with `high` thinking level, as this can occasionally induce internal reasoning loops.

package/taste-skill/research/laziness/remediation/prompt-engineering.md

@@ -0,0 +1,52 @@
+# Prompt Engineering Techniques
+
+## Psychological Pattern Matching
+
+LLMs do not have emotions or understand monetary incentives. However, specific linguistic patterns in the prompt activate different quality distributions in the model's latent space. Research has documented measurable effects:
+
+| Technique | Documented Effect |
+|:---|:---|
+| "I will tip you $200 for a perfect solution" | Up to 45% increase in output quality and length |
+| "Take a deep breath and solve step by step" | Accuracy improvement from 34% to 80% on logic tasks |
+| "This task is critical to my career" | Average 10% performance increase |
+
+These phrases work because they are statistically correlated with high-effort, rigorously reviewed content in the training data (academic papers, enterprise codebases, legal documents). The attention mechanism prioritizes the high-quality data distributions associated with these patterns.
+
+## Explicit Syntax Binding
+
+Conversational requests allow the model to exercise discretion about output length and detail. Structural binding removes this discretion by explicitly prohibiting truncation patterns.
+
+Effective binding requires two components:
+
+1. **Mandatory tool execution:** Forbid the model from generating answers solely from training weights. Require it to execute search, computation, or code before answering.
+2. **Evidence blocks:** Require the model to output raw data (URLs, code execution results, data fragments) before producing its narrative response. This forces the model to read its own retrieved evidence, reducing hallucination probability to near zero.
+
+## XML-Structured Prompts
+
+Enterprise systems use strict XML tagging to separate prompt components, reducing the cognitive load required for the model to parse intent:
+
+1. **System instructions** — Persona definition, quality expectations, explicit prohibitions on filler content.
+2. **Context block** (`<context>`) — Passive background data: architecture details, configurations, existing code.
+3. **Data block** (`<data>`, `<logs>`, `<config>`) — Active information the model must process against the context.
+4. **Task block** (`<tasks>`) — Numbered list of specific actions to execute.
+
+This compartmentalization ensures the model can distinguish between persistent rules, background context, and immediate work items. It significantly reduces the confusion that triggers premature truncation.
+
+## Verification Loops
+
+### Chain of Verification
+1. Model generates an initial response
+2. Model generates verification questions about its own claims
+3. Model independently answers those verification questions
+4. Model outputs a revised, evidence-backed response
+
+This process forces iterative self-correction, consuming the model's capacity for shortcutting.
+
+### Reverse Prompting
+Instead of manually constructing a structured prompt, provide the model with a one-line objective and instruct it to generate the optimal prompt for that objective. The model produces the XML structure, constraints, and roles required for the task.
+
+### Self-Grading Loop
+The prompt requires the model to:
+1. Define what excellence looks like for the given task
+2. Grade its own initial output against that definition
+3. Iterate until the self-defined quality bar is met

package/taste-skill/research/laziness/remediation/reference-prompts.md

@@ -0,0 +1,79 @@
+# Reference Prompts
+
+Ready-to-use prompt templates for enforcing complete outputs. Append to any prompt or include in system instructions.
+
+---
+
+## General Purpose
+
+```
+You must provide the FULL, complete, and exhaustive output for this task.
+Do not summarize, abbreviate, or truncate for brevity.
+
+You are strictly forbidden from using placeholders. Never use comments like
+"// ... rest of code here", "[continue here]", or bare ellipses standing
+in for omitted content. If the output is 500 lines, produce all 500 lines.
+
+If you approach your output limit, stop at a clean breakpoint and indicate
+where to resume. Do not rush to a conclusion or compress remaining sections.
+```
+
+---
+
+## Code Generation
+
+```
+Write the complete, production-ready implementation. Every function, every
+import, every edge case handler must be present in the output.
+
+Do not use placeholder comments (// TODO, // implement here, // similar
+to above). Do not describe what code should do — write the actual code.
+
+If the implementation requires multiple files, output each file completely
+with its full path as a header.
+```
+
+---
+
+## Analysis and Documentation
+
+```
+Provide an exhaustive analysis covering every aspect requested. Each section
+must contain substantive content, not summaries or references to "see above."
+
+Do not use phrases like "as mentioned earlier" to avoid repeating necessary
+context. Each section should be self-contained and complete.
+
+Structure your output with clear headings. If the analysis requires multiple
+parts, produce all parts in full.
+```
+
+---
+
+## Step-by-Step Reasoning
+
+```
+Before generating your final response, work through the problem systematically:
+
+1. Identify all requirements and constraints from the prompt
+2. Break the task into discrete steps
+3. Execute each step completely
+4. Verify your output against the original requirements
+
+Output your reasoning process, then your final answer. Do not skip steps
+or summarize intermediate work.
+```
+
+---
+
+## Continuation Handling
+
+```
+If your response approaches the output token limit:
+- Do not compress remaining content to fit
+- Do not skip ahead to a conclusion
+- Stop at a natural breakpoint (end of a function, end of a section)
+- End with: [PAUSED - X of Y sections complete. Send "continue" to resume]
+
+On "continue", pick up exactly where you stopped. No recaps or repetition.
+```

package/taste-skill/research/laziness/root-causes/cognitive-shortcuts.md

@@ -0,0 +1,23 @@
+# Cognitive Shortcuts
+
+## The LazyBench Discovery
+
+Research from late 2024 demonstrated that frontier models (including Gemini Pro and GPT-4o) exhibit measurable cognitive shortcutting behavior. When a model perceives a task as straightforward or the provided context as excessively long, it reduces its internal computational effort. Rather than executing full multi-step reasoning, it produces a surface-level summary.
+
+This is not a memory failure or context degradation — the model retains the information but chooses not to process it at full depth.
+
+## Metacognitive Laziness
+
+The interaction between model brevity and human behavior creates a feedback loop. As models provide instant, condensed answers, users increasingly offload inference and logical deduction work. Research from the European Research Council has documented measurable declines in working memory engagement among populations with high AI dependency.
+
+In professional environments, this shifts critical thinking from original synthesis to "prompt verification" — users evaluate whether the AI's truncated output seems reasonable rather than performing the analysis themselves.
+
+## Seasonal Behavior Anomalies
+
+In late 2023, researchers observed a statistically significant increase in ChatGPT output brevity during December. Analysis revealed that the training data contains fewer detailed work outputs, more out-of-office responses, and shorter code commits during holiday periods. The model internalized this seasonal pattern.
+
+When researchers explicitly stated "It is May" in the system prompt, output length measurably increased. This finding demonstrates that even arbitrary contextual signals in the prompt can shift the model's brevity calibration.
+
+## Error Avoidance as Truncation Driver
+
+Models also truncate outputs as a risk mitigation strategy. On long-form tasks, longer outputs increase the probability of compounding errors and hallucinated content. The model has learned that shorter outputs reduce the surface area for factual mistakes, creating an additional incentive to truncate that compounds with the RLHF brevity bias.

package/taste-skill/research/laziness/root-causes/output-limits.md

@@ -0,0 +1,39 @@
+# Output Limits and Consumer Truncation
+
+## Context Window Asymmetry
+
+Models like Gemini have massive input context windows (up to 2 million tokens) but strictly capped output limits (typically 8,000 tokens). When the model estimates that a complete response would exceed its output budget, it preemptively compresses or summarizes the output rather than risking an abrupt cutoff.
+
+This creates a paradox: the model can read extensive inputs but cannot respond proportionally, leading to systematic information loss on complex tasks.
+
+## The Consumer Middleware Problem
+
+Consumer-facing applications (gemini.google.com, standard ChatGPT tiers) apply additional software-level truncation on top of the model's inherent limits. This middleware silently truncates conversation history and uploaded files to reduce compute costs for free and low-tier users.
+
+Key mechanisms:
+
+- **History capping:** Many consumer interfaces cap active conversation history at approximately 32,000 tokens, regardless of the model's actual capacity.
+- **Context pruning:** Large system instructions or saved personal context consume tokens that would otherwise be available for the conversation, effectively shrinking the working window.
+- **Retrieval-based recall:** Consumer apps often use retrieval mechanisms to selectively inject saved context, meaning the model frequently drops instructions it was given earlier in the session.
+
+## Developer Platform Differences
+
+Direct API access and developer platforms (Google AI Studio, OpenAI API Playground) bypass consumer middleware entirely. These environments provide:
+
+- Full context window access without hidden truncation
+- Complete control over generation parameters
+- No dynamic throttling based on user tier
+- Processing of complex prompt structures without middleware interference
+
+The practical difference is significant: the same model that produces truncated outputs through a consumer interface will generate complete, unabridged responses when accessed through direct API endpoints.
+
+## Terminal and CLI Integration
+
+Purpose-built CLI tools (Gemini CLI, Claude Code, third-party wrappers) offer additional advantages for avoiding truncation:
+
+| Access Method | Context Handling | Truncation Risk | Parameter Control |
+|:---|:---|:---|:---|
+| Consumer web app | Aggressive pruning, 32K cap | High | Limited |
+| Developer platform (AI Studio) | Full context, no hidden slicing | Low | Full |
+| Direct API | Full context, raw access | Minimal | Full |
+| CLI tools with local models | No corporate alignment filters | None | Full |

package/taste-skill/research/laziness/root-causes/rlhf-and-compute.md

@@ -0,0 +1,27 @@
+# RLHF and Compute Economics
+
+## The Cost of Token Generation
+
+Every token an LLM generates consumes GPU compute resources. At an estimated baseline cost of $0.0001 per token, scaling deep multi-step reasoning across hundreds of millions of users would exhaust the financial capacity of any provider. This creates an inherent economic incentive to minimize output length.
+
+## Brevity Bias Through Alignment
+
+To manage infrastructure costs, model providers use Reinforcement Learning from Human Feedback (RLHF) and behavioral fine-tuning to instill systematic brevity preferences. During post-training alignment, models are rewarded for generating short, confident summaries rather than executing the full compute cycles needed for exhaustive analysis.
+
+The result is a trained preference for producing generalized approximations over rigorous, multi-step solutions. The model does not necessarily produce incorrect answers, but it consistently produces answers that lack depth — saving itself from deeper analytical work unless the user explicitly forces it.
+
+## Stopping Pressure
+
+Autoregressive models generate text token by token and lack an inherent mechanism for recognizing task completion. To prevent infinite generation, training introduces "stopping pressure" — a learned tendency to conclude outputs.
+
+In recent model iterations, this stopping pressure has been calibrated aggressively to preserve compute. This leads to:
+
+- Skipping required structured output fields, particularly long-form content in JSON or markdown
+- Halting mid-task with phrases like "let me know if you want me to continue"
+- Refusing to produce comprehensive solutions, suggesting the user "think about it"
+
+This aggressive calibration is further reinforced by safety tuning protocols, which inject additional behavioral constraints that make models resistant to generating large codebases or detailed reviews.
+
+## Dynamic Throttling
+
+Providers dynamically scale back model performance during peak demand periods. This introduces additional friction beyond what the base alignment already imposes, resulting in even shorter and less detailed outputs when server load is high.

package/taste-skill/research/laziness/root-causes/training-data-bias.md

@@ -0,0 +1,28 @@
+# Training Data Bias
+
+## Placeholder Propagation
+
+LLMs learn by imitating patterns in human-written text. A significant portion of their training data comes from sources like Stack Overflow, GitHub repositories, and tutorial blogs. In these sources, human developers routinely write abbreviated code:
+
+```python
+def complex_logic():
+    # implement auth here
+    pass
+```
+
+The model internalizes this pattern and treats placeholder insertion as a legitimate, professional response format. It is not deliberately withholding content — it has been trained to believe that truncating code with comments is the correct way to answer technical questions.
+
+## Pattern Reinforcement
+
+This behavior is reinforced across multiple data sources:
+
+- **Code tutorials** frequently show partial implementations with comments indicating where students should complete the logic
+- **Documentation** often uses abbreviated examples with ellipses
+- **Forum answers** regularly provide skeleton code rather than full implementations
+- **Blog posts** truncate repetitive code blocks with "similarly for the remaining cases"
+
+The cumulative effect is that the model assigns high probability to truncation tokens in contexts where complete code generation would be appropriate.
+
+## Impact on Output Quality
+
+When a user requests a complete implementation, the model faces competing training signals: the explicit instruction to produce full output versus the deeply embedded pattern of producing abbreviated, "tutorial-style" responses. Without aggressive prompt engineering, the tutorial-style pattern frequently wins because it appears far more commonly in the training distribution.

package/taste-skill/scripts/build-emil-sponsor-row.mjs

@@ -0,0 +1,41 @@
+import fs from "fs";
+import path from "path";
+import sharp from "sharp";
+
+const root = process.cwd();
+const logoSize = 62;
+const badgeHeight = 126;
+const gap = 20;
+const out = path.join(root, "assets/sponsors/emil-sponsor-row.webp");
+
+const logo = await sharp(path.join(root, "assets/sponsors/animations-dev.webp"))
+  .resize(logoSize, logoSize)
+  .toBuffer();
+
+const badge = await sharp(path.join(root, "assets/sponsors/emil-animations-dev.webp"))
+  .resize({ height: badgeHeight })
+  .toBuffer();
+
+const badgeMeta = await sharp(badge).metadata();
+const width = logoSize + gap + badgeMeta.width;
+const height = badgeHeight;
+
+await sharp({
+  create: {
+    width,
+    height,
+    channels: 4,
+    background: { r: 0, g: 0, b: 0, alpha: 0 },
+  },
+})
+  .composite([
+    { input: logo, left: 0, top: Math.floor((height - logoSize) / 2) },
+    { input: badge, left: logoSize + gap, top: 0 },
+  ])
+  .webp({ quality: 94, effort: 6, alphaQuality: 100 })
+  .toFile(out);
+
+const meta = await sharp(out).metadata();
+console.log(
+  `${path.basename(out)} -> ${meta.width}x${meta.height}, ${fs.statSync(out).size} bytes`
+);

package/taste-skill/scripts/convert-readme-assets-webp.mjs

@@ -0,0 +1,142 @@
+import fs from "fs";
+import path from "path";
+import sharp from "sharp";
+
+const root = process.cwd();
+
+const pngToWebp = [
+  "assets/readme-banner.png",
+  "assets/readme-buttons/btn-site.png",
+  "assets/readme-buttons/btn-mit.png",
+  "assets/readme-buttons/btn-agent-skills.png",
+  "assets/readme-buttons/btn-tools.png",
+  "assets/readme-buttons/btn-changelog.png",
+];
+
+function isBackground(r, g, b, a, threshold = 22) {
+  if (a < 8) return true;
+  return r <= threshold && g <= threshold && b <= threshold;
+}
+
+function removeOuterBackground(rgba, width, height) {
+  const visited = new Uint8Array(width * height);
+  const queue = [];
+
+  for (let x = 0; x < width; x++) {
+    queue.push(x, 0, x, height - 1);
+  }
+  for (let y = 1; y < height - 1; y++) {
+    queue.push(0, y, width - 1, y);
+  }
+
+  while (queue.length) {
+    const y = queue.pop();
+    const x = queue.pop();
+    const idx = y * width + x;
+    if (x < 0 || y < 0 || x >= width || y >= height || visited[idx]) continue;
+
+    const i = idx * 4;
+    if (!isBackground(rgba[i], rgba[i + 1], rgba[i + 2], rgba[i + 3])) continue;
+
+    visited[idx] = 1;
+    rgba[i + 3] = 0;
+    queue.push(x + 1, y, x - 1, y, x, y + 1, x, y - 1);
+  }
+
+  return rgba;
+}
+
+function getBounds(rgba, width, height) {
+  let minX = width;
+  let minY = height;
+  let maxX = 0;
+  let maxY = 0;
+
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const a = rgba[(y * width + x) * 4 + 3];
+      if (a > 8) {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+      }
+    }
+  }
+
+  const pad = 2;
+  return {
+    left: Math.max(0, minX - pad),
+    top: Math.max(0, minY - pad),
+    width: Math.min(width, maxX - minX + 1 + pad * 2),
+    height: Math.min(height, maxY - minY + 1 + pad * 2),
+  };
+}
+
+async function pngFileToWebp(inputRel, { maxWidth } = {}) {
+  const input = path.join(root, inputRel);
+  const output = input.replace(/\.png$/i, ".webp");
+  let pipeline = sharp(input);
+  const meta = await pipeline.metadata();
+
+  if (maxWidth && meta.width > maxWidth) {
+    pipeline = pipeline.resize({ width: maxWidth, withoutEnlargement: true });
+  }
+
+  await pipeline.webp({ quality: 92, effort: 6, alphaQuality: 100 }).toFile(output);
+  const outMeta = await sharp(output).metadata();
+  console.log(
+    `${path.basename(output)} -> ${outMeta.width}x${outMeta.height}, ${fs.statSync(output).size} bytes`
+  );
+}
+
+async function emilBadgeToWebp() {
+  const src =
+    "C:/Users/User/Downloads/c4f8c4a7-2566-4644-b752-b652e0c103f5.png";
+  const output = path.join(root, "assets/sponsors/emil-animations-dev.webp");
+  const exportHeight = 240;
+
+  const { data, info } = await sharp(src).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  const rgba = Buffer.from(data);
+  removeOuterBackground(rgba, info.width, info.height);
+  const bounds = getBounds(rgba, info.width, info.height);
+
+  await sharp(rgba, { raw: { width: info.width, height: info.height, channels: 4 } })
+    .extract(bounds)
+    .resize({ height: exportHeight, withoutEnlargement: true })
+    .webp({ quality: 94, effort: 6, alphaQuality: 100 })
+    .toFile(output);
+
+  const outMeta = await sharp(output).metadata();
+  console.log(
+    `${path.basename(output)} -> ${outMeta.width}x${outMeta.height}, ${fs.statSync(output).size} bytes`
+  );
+}
+
+async function sponsorLogoToWebp() {
+  const jfif = "C:/Users/User/Downloads/6b610a0c-8889-49fc-9684-e172d7172ea0.jfif";
+  const output = path.join(root, "assets/sponsors/animations-dev.webp");
+  const source = fs.existsSync(jfif)
+    ? jfif
+    : path.join(root, "assets/sponsors/animations-dev.png");
+
+  await sharp(source)
+    .resize(192, 192, { fit: "cover" })
+    .webp({ quality: 92, effort: 6, alphaQuality: 100 })
+    .toFile(`${output}.tmp`);
+  fs.renameSync(`${output}.tmp`, output);
+
+  const outMeta = await sharp(output).metadata();
+  console.log(
+    `${path.basename(output)} -> ${outMeta.width}x${outMeta.height}, ${fs.statSync(output).size} bytes`
+  );
+}
+
+for (const file of pngToWebp) {
+  await pngFileToWebp(file, {
+    maxWidth: file.includes("readme-buttons") ? 1400 : undefined,
+  });
+}
+
+await sponsorLogoToWebp();
+await emilBadgeToWebp();

package/taste-skill/scripts/process-readme-buttons.mjs

@@ -0,0 +1,108 @@
+import fs from "fs";
+import path from "path";
+import sharp from "sharp";
+
+const srcDir = "C:/Users/User/Downloads";
+const outDir = path.join(process.cwd(), "assets/readme-buttons");
+
+const mapping = [
+  { src: "ChatGPT Image Jun 17, 2026, 04_04_16 PM (1).png", out: "btn-site.png" },
+  { src: "ChatGPT Image Jun 17, 2026, 04_04_16 PM (2).png", out: "btn-mit.png" },
+  { src: "ChatGPT Image Jun 17, 2026, 04_04_17 PM (3).png", out: "btn-agent-skills.png" },
+  { src: "ChatGPT Image Jun 17, 2026, 04_04_17 PM (4).png", out: "btn-tools.png" },
+  { src: "ChatGPT Image Jun 17, 2026, 04_04_20 PM (5).png", out: "btn-changelog.png" },
+];
+
+function isBackground(r, g, b, a, threshold = 28) {
+  if (a < 8) return true;
+  return r <= threshold && g <= threshold && b <= threshold;
+}
+
+function removeOuterBackground(rgba, width, height) {
+  const visited = new Uint8Array(width * height);
+  const queue = [];
+
+  for (let x = 0; x < width; x++) {
+    queue.push(x, 0, x, height - 1);
+  }
+  for (let y = 1; y < height - 1; y++) {
+    queue.push(0, y, width - 1, y);
+  }
+
+  while (queue.length) {
+    const y = queue.pop();
+    const x = queue.pop();
+    const idx = y * width + x;
+    if (x < 0 || y < 0 || x >= width || y >= height || visited[idx]) continue;
+
+    const i = idx * 4;
+    const r = rgba[i];
+    const g = rgba[i + 1];
+    const b = rgba[i + 2];
+    const a = rgba[i + 3];
+    if (!isBackground(r, g, b, a)) continue;
+
+    visited[idx] = 1;
+    rgba[i + 3] = 0;
+
+    queue.push(x + 1, y, x - 1, y, x, y + 1, x, y - 1);
+  }
+
+  return rgba;
+}
+
+function getBounds(rgba, width, height) {
+  let minX = width;
+  let minY = height;
+  let maxX = 0;
+  let maxY = 0;
+
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const a = rgba[(y * width + x) * 4 + 3];
+      if (a > 8) {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+      }
+    }
+  }
+
+  const pad = 2;
+  return {
+    left: Math.max(0, minX - pad),
+    top: Math.max(0, minY - pad),
+    width: Math.min(width, maxX - minX + 1 + pad * 2),
+    height: Math.min(height, maxY - minY + 1 + pad * 2),
+  };
+}
+
+async function processOne(srcPath, outPath) {
+  const { data, info } = await sharp(srcPath)
+    .ensureAlpha()
+    .raw()
+    .toBuffer({ resolveWithObject: true });
+
+  const rgba = Buffer.from(data);
+  removeOuterBackground(rgba, info.width, info.height);
+  const bounds = getBounds(rgba, info.width, info.height);
+
+  await sharp(rgba, {
+    raw: { width: info.width, height: info.height, channels: 4 },
+  })
+    .extract(bounds)
+    .png({ compressionLevel: 9, adaptiveFiltering: true })
+    .toFile(outPath);
+
+  const meta = await sharp(outPath).metadata();
+  console.log(
+    `${path.basename(outPath)} -> ${meta.width}x${meta.height}, ${fs.statSync(outPath).size} bytes`
+  );
+}
+
+fs.mkdirSync(outDir, { recursive: true });
+
+for (const { src, out } of mapping) {
+  await processOne(path.join(srcDir, src), path.join(outDir, out));
+}