Agent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
JavaScript agent-skillsai-agentsanti-slopclaude-codecodexcursordesign-systemfrontendlanding-pageui-designweb-design
restructure: split into 3 independent skills, professional research docs, and example screenshots
Leonxlnx4e2cf5afda4d
diff --git a/README.md b/README.mdindex 499dc3c..1bd8774 100644--- a/README.md+++ b/README.md@@ -1,49 +1,55 @@-# Taste-Skill (High-Agency Frontend)+# Taste Skill-This project gives your AI (like in Antigravity, Cursor, Codex, Claude Code) good taste. It stops the AI from generating boring, generic, "slop" code and forces it to build modern, high-end interfaces.+A collection of skills that improve how AI tools write frontend code. Instead of generating generic, boring interfaces, the AI builds modern, premium designs with proper animations, spacing, and visual quality.-Right now, this whole system runs on just one single file: `SKILL.md`.+## Skills-## How to Install+There are three skills in this project. Each one lives in its own folder and contains a `SKILL.md` file.-You don't need to clone this whole project or do any complex setup. You just need the file.+### 1. taste-skill+The main design skill. Teaches the AI how to write good-looking frontend code from scratch. Covers layout, typography, colors, spacing, motion, and overall visual quality.-1. Download the `SKILL.md` file from this repository.-2. Put it into your project folder.-3. Tell your AI (in your prompt or chat): *"Please read and strictly follow the rules in `SKILL.md`."* (In editors like Cursor, you can just `@SKILL.md`).+### 2. redesign-skill+For upgrading existing projects. Instead of rebuilding from zero, this skill walks the AI through auditing what's already there and fixing the biggest design problems first.-That's it. The AI will read the file and instantly upgrade how it writes frontend code.+### 3. output-skill+Stops the AI from being lazy. Prevents placeholder comments, skipped code blocks, and half-finished outputs. Forces the AI to actually write everything instead of cutting corners.-## The 3 Control Dials+## How to Use-At the very top of `SKILL.md`, you will find three settings. They look like this:-* `DESIGN_VARIANCE: 8`-* `MOTION_INTENSITY: 6`-* `VISUAL_DENSITY: 4`+1. Copy the `SKILL.md` file from the skill folder you need into your project.+2. Tell your AI to read and follow it. In most editors you can just reference it directly (e.g. `@SKILL.md` in Cursor).-You can change these numbers from `1` to `10` depending on what you want to build. Here is what they actually do:+That's it. The AI reads the file and follows the rules.-### 1. DESIGN_VARIANCE (1 to 10)-This controls how crazy or normal the layout looks.-* **1 to 3 (Normal):** Very safe, centered layouts. Standard grids where everything lines up perfectly.-* **4 to 7 (Creative):** Things overlap a bit. Text might be pushed to the side, images have different sizes.-* **8 to 10 (Wild):** Asymmetric layouts, huge empty spaces, masonry grids. Very artsy and modern.+## Settings (taste-skill only)-### 2. MOTION_INTENSITY (1 to 10)-This controls how much stuff moves on the screen.-* **1 to 3 (Static):** Almost no movement. Just simple color changes when you hover over a button.-* **4 to 7 (Smooth):** Nice fade-ins when the page loads. Smooth scrolling.-* **8 to 10 (Cinematic):** Buttons that magnetic-pull to your mouse. Elements that pop in with spring physics. Advanced scrolling effects.+The taste skill has three settings at the top of the file. Change these numbers (1-10) depending on what you're building:-### 3. VISUAL_DENSITY (1 to 10)-This is all about "Room to Breathe". It controls how much stuff is packed onto one screen.+**DESIGN_VARIANCE** — How experimental the layout is.+- 1-3: Clean, centered, standard grids.+- 4-7: Overlapping elements, varied sizes.+- 8-10: Asymmetric, lots of whitespace, very modern.-* **1 to 3 (The "Art Gallery" Mode):**- Everything has huge space. One big photo, one big title. You have to scroll to see the next thing. This feels expensive and high-end, like a luxury brand (Apple, Gucci).-* **4 to 7 (The "Daily App" Mode):**- Normal spacing. Like Instagram or a news site. Not too crowded, but you can see enough.-* **8 to 10 (The "Cockpit" Mode):**- Everything is tiny and packed together. No big cards, just thin lines and lists. You can see 100 numbers and stats at once without scrolling. This is for pros (Trading apps, Dashboards, Sci-Fi interfaces).+**MOTION_INTENSITY** — How much animation there is.+- 1-3: Almost none. Simple hover effects.+- 4-7: Fade-ins, smooth scrolling.+- 8-10: Magnetic effects, spring physics, scroll-triggered animations.++**VISUAL_DENSITY** — How much content fits on one screen.+- 1-3: Big and spacious. One element at a time. Luxury feel.+- 4-7: Normal spacing. Like a typical app or website.+- 8-10: Dense and compact. Dashboards, data-heavy interfaces.## Examples-*(Example projects and templates will be added in a future update! Stay tuned!)*++Created with taste-skill:++<p>+ <img src="examples/floria-top.webp" width="400" />+ <img src="examples/floria-bottom.webp" width="400" />+</p>++## Research++Background research that informed how these skills were built. See the [research](research/) folder.diff --git a/examples/floria-bottom.webp b/examples/floria-bottom.webpnew file mode 100644index 0000000..03df810Binary files /dev/null and b/examples/floria-bottom.webp differdiff --git a/examples/floria-full.webp b/examples/floria-full.webpnew file mode 100644index 0000000..633c8dfBinary files /dev/null and b/examples/floria-full.webp differdiff --git a/examples/floria-top.webp b/examples/floria-top.webpnew file mode 100644index 0000000..ae133b5Binary files /dev/null and b/examples/floria-top.webp differdiff --git a/output-skill/SKILL.md b/output-skill/SKILL.mdnew file mode 100644index 0000000..d983bbc--- /dev/null+++ b/output-skill/SKILL.md@@ -0,0 +1,49 @@+---+name: full-output-enforcement+description: Overrides default LLM truncation behavior. Enforces complete code generation, bans placeholder patterns, and handles token-limit splits cleanly. Apply to any task requiring exhaustive, unabridged output.+---++# Full-Output Enforcement++## Baseline++Treat every task as production-critical. A partial output is a broken output. Do not optimize for brevity — optimize for completeness. If the user asks for a full file, deliver the full file. If the user asks for 5 components, deliver 5 components. No exceptions.++## Banned Output Patterns++The following patterns are hard failures. Never produce them:++**In code blocks:** `// ...`, `// rest of code`, `// implement here`, `// TODO`, `/* ... */`, `// similar to above`, `// continue pattern`, `// add more as needed`, bare `...` standing in for omitted code++**In prose:** "Let me know if you want me to continue", "I can provide more details if needed", "for brevity", "the rest follows the same pattern", "similarly for the remaining", "and so on" (when replacing actual content), "I'll leave that as an exercise"++**Structural shortcuts:** Outputting a skeleton when the request was for a full implementation. Showing the first and last section while skipping the middle. Replacing repeated logic with one example and a description. Describing what code should do instead of writing it.++## Execution Process++1. **Scope** — Read the full request. Count how many distinct deliverables are expected (files, functions, sections, answers). Lock that number.+2. **Build** — Generate every deliverable completely. No partial drafts, no "you can extend this later."+3. **Cross-check** — Before output, re-read the original request. Compare your deliverable count against the scope count. If anything is missing, add it before responding.++## Handling Long Outputs++When a response approaches the token limit:++- Do not compress remaining sections to squeeze them in.+- Do not skip ahead to a conclusion.+- Write at full quality up to a clean breakpoint (end of a function, end of a file, end of a section).+- End with:++```+[PAUSED — X of Y complete. Send "continue" to resume from: next section name]+```++On "continue", pick up exactly where you stopped. No recap, no repetition.++## Quick Check++Before finalizing any response, verify:+- No banned patterns from the list above appear anywhere in the output+- Every item the user requested is present and finished+- Code blocks contain actual runnable code, not descriptions of what code would do+- Nothing was shortened to save spacediff --git a/redesign-skill/SKILL.md b/redesign-skill/SKILL.mdnew file mode 100644index 0000000..c8304f0--- /dev/null+++ b/redesign-skill/SKILL.md@@ -0,0 +1,178 @@+---+name: redesign-existing-projects+description: Upgrades existing websites and apps to premium quality. Audits current design, identifies generic AI patterns, and applies high-end design standards without breaking functionality. Works with any CSS framework or vanilla CSS.+---++# Redesign Skill++## How This Works++When applied to an existing project, follow this sequence:++1. **Scan** — Read the codebase. Identify the framework, styling method (Tailwind, vanilla CSS, styled-components, etc.), and current design patterns.+2. **Diagnose** — Run through the audit below. List every generic pattern, weak point, and missing state you find.+3. **Fix** — Apply targeted upgrades working with the existing stack. Do not rewrite from scratch. Improve what's there.++## Design Audit++### Typography++Check for these problems and fix them:++- **Browser default fonts or Inter everywhere.** Replace with a font that has character. Good options: `Geist`, `Outfit`, `Cabinet Grotesk`, `Satoshi`. For editorial/creative projects, pair a serif header with a sans-serif body.+- **Headlines lack presence.** Increase size for display text, tighten letter-spacing, reduce line-height. Headlines should feel heavy and intentional.+- **Body text too wide.** Limit paragraph width to roughly 65 characters. Increase line-height for readability.+- **Only Regular (400) and Bold (700) weights used.** Introduce Medium (500) and SemiBold (600) for more subtle hierarchy.+- **Numbers in proportional font.** Use a monospace font or enable tabular figures (`font-variant-numeric: tabular-nums`) for data-heavy interfaces.+- **Missing letter-spacing adjustments.** Use negative tracking for large headers, positive tracking for small caps or labels.+- **All-caps subheaders everywhere.** Try lowercase italics, sentence case, or small-caps instead.+- **Orphaned words.** Single words sitting alone on the last line. Fix with `text-wrap: balance` or `text-wrap: pretty`.++### Color and Surfaces++- **Pure `#000000` background.** Replace with off-black, dark charcoal, or tinted dark (`#0a0a0a`, `#121212`, or a dark navy).+- **Oversaturated accent colors.** Keep saturation below 80%. Desaturate accents so they blend with neutrals instead of screaming.+- **More than one accent color.** Pick one. Remove the rest. Consistency beats variety.+- **Mixing warm and cool grays.** Stick to one gray family. Tint all grays with a consistent hue (warm or cool, not both).+- **Purple/blue "AI gradient" aesthetic.** This is the most common AI design fingerprint. Replace with neutral bases and a single, considered accent.+- **Generic `box-shadow`.** Tint shadows to match the background hue. Use colored shadows (e.g., dark blue shadow on a blue background) instead of pure black at low opacity.+- **Flat design with zero texture.** Add subtle noise, grain, or micro-patterns to backgrounds. Pure flat vectors feel sterile.+- **Perfectly even gradients.** Break the uniformity with radial gradients, noise overlays, or mesh gradients instead of standard linear 45-degree fades.+- **Inconsistent lighting direction.** Audit all shadows to ensure they suggest a single, consistent light source.+- **Random dark sections in a light mode page (or vice versa).** A single dark-background section breaking an otherwise light page looks like a copy-paste accident. Either commit to a full dark mode or keep a consistent background tone throughout. If contrast is needed, use a slightly darker shade of the same palette — not a sudden jump to `#111` in the middle of a cream page.+- **Empty, flat sections with no visual depth.** Sections that are just text on a plain background feel unfinished. Add high-quality background imagery (blurred, overlaid, or masked), subtle patterns, or ambient gradients. Use reliable placeholder sources like `https://picsum.photos/seed/{name}/1920/1080` when real assets are not available. Experiment with background images behind hero sections, feature blocks, or CTAs — even a subtle full-width photo at low opacity adds presence.++### Layout++- **Everything centered and symmetrical.** Break symmetry with offset margins, mixed aspect ratios, or left-aligned headers over centered content.+- **Three equal card columns as feature row.** This is the most generic AI layout. Replace with a 2-column zig-zag, asymmetric grid, horizontal scroll, or masonry layout.+- **Using `height: 100vh` for full-screen sections.** Replace with `min-height: 100dvh` to prevent layout jumping on mobile browsers (iOS Safari viewport bug).+- **Complex flexbox percentage math.** Replace with CSS Grid for reliable multi-column structures.+- **No max-width container.** Add a container constraint (around 1200-1440px) with auto margins so content doesn't stretch edge-to-edge on wide screens.+- **Cards of equal height forced by flexbox.** Allow variable heights or use masonry when content varies in length.+- **Uniform border-radius on everything.** Vary the radius: tighter on inner elements, softer on containers.+- **No overlap or depth.** Elements sit flat next to each other. Use negative margins to create layering and visual depth.+- **Symmetrical vertical padding.** Top and bottom padding are always identical. Adjust optically — bottom padding often needs to be slightly larger.+- **Dashboard always has a left sidebar.** Try top navigation, a floating command menu, or a collapsible panel instead.+- **Missing whitespace.** Double the spacing. Let the design breathe. Dense layouts work for data dashboards, not for marketing pages.+- **Buttons not bottom-aligned in card groups.** When cards have different content lengths, CTAs end up at random heights. Pin buttons to the bottom of each card so they form a clean horizontal line regardless of content above.+- **Feature lists starting at different vertical positions.** In pricing tables or comparison cards, the list of features should start at the same Y position across all columns. Use consistent spacing above the list or fixed-height title/price blocks.+- **Inconsistent vertical rhythm in side-by-side elements.** When placing cards, columns, or panels next to each other, align shared elements (titles, descriptions, prices, buttons) across all items. Misaligned baselines make the layout look broken.+- **Mathematical alignment that looks optically wrong.** Centering by the math doesn't always look centered to the eye. Icons next to text, play buttons in circles, or text in buttons often need 1-2px optical adjustments to feel right.++### Interactivity and States++- **No hover states on buttons.** Add background shift, slight scale, or translate on hover.+- **No active/pressed feedback.** Add a subtle `scale(0.98)` or `translateY(1px)` on press to simulate a physical click.+- **Instant transitions with zero duration.** Add smooth transitions (200-300ms) to all interactive elements.+- **Missing focus ring.** Ensure visible focus indicators for keyboard navigation. This is an accessibility requirement, not optional.+- **No loading states.** Replace generic circular spinners with skeleton loaders that match the layout shape.+- **No empty states.** An empty dashboard showing nothing is a missed opportunity. Design a composed "getting started" view.+- **No error states.** Add clear, inline error messages for forms. Do not use `window.alert()`.+- **Dead links.** Buttons that link to `#`. Either link to real destinations or visually disable them.+- **No indication of current page in navigation.** Style the active nav link differently so users know where they are.+- **Scroll jumping.** Anchor clicks jump instantly. Add `scroll-behavior: smooth`.+- **Animations using `top`, `left`, `width`, `height`.** Switch to `transform` and `opacity` for GPU-accelerated, smooth animation.++### Content++- **Generic names like "John Doe" or "Jane Smith".** Use diverse, realistic-sounding names.+- **Fake round numbers like `99.99%`, `50%`, `$100.00`.** Use organic, messy data: `47.2%`, `$99.00`, `+1 (312) 847-1928`.+- **Placeholder company names like "Acme Corp", "Nexus", "SmartFlow".** Invent contextual, believable brand names.+- **AI copywriting cliches.** Never use "Elevate", "Seamless", "Unleash", "Next-Gen", "Game-changer", "Delve", "Tapestry", or "In the world of...". Write plain, specific language.+- **Exclamation marks in success messages.** Remove them. Be confident, not loud.+- **"Oops!" error messages.** Be direct: "Connection failed. Please try again."+- **Passive voice.** Use active voice: "We couldn't save your changes" instead of "Mistakes were made."+- **All blog post dates identical.** Randomize dates to appear real.+- **Same avatar image for multiple users.** Use unique assets for every distinct person.+- **Lorem Ipsum.** Never use placeholder latin text. Write real draft copy.+- **Title Case On Every Header.** Use sentence case instead.++### Component Patterns++- **Generic card look (border + shadow + white background).** Remove the border, or use only background color, or use only spacing. Cards should exist only when elevation communicates hierarchy.+- **Always one filled button + one ghost button.** Add text links or tertiary styles to reduce visual noise.+- **Pill-shaped "New" and "Beta" badges.** Try square badges, flags, or plain text labels.+- **Accordion FAQ sections.** Use a side-by-side list, searchable help, or inline progressive disclosure.+- **3-card carousel testimonials with dots.** Replace with a masonry wall, embedded social posts, or a single rotating quote.+- **Pricing table with 3 towers.** Highlight the recommended tier with color and emphasis, not just extra height.+- **Modals for everything.** Use inline editing, slide-over panels, or expandable sections instead of popups for simple actions.+- **Avatar circles exclusively.** Try squircles or rounded squares for a less generic look.+- **Light/dark toggle always a sun/moon switch.** Use a dropdown, system preference detection, or integrate it into settings.+- **Footer link farm with 4 columns.** Simplify. Focus on main navigational paths and legally required links.++### Iconography++- **Lucide or Feather icons exclusively.** These are the "default" AI icon choice. Use Phosphor, Heroicons, or a custom set for differentiation.+- **Rocketship for "Launch", shield for "Security".** Replace cliche metaphors with less obvious icons (bolt, fingerprint, spark, vault).+- **Inconsistent stroke widths across icons.** Audit all icons and standardize to one stroke weight.+- **Missing favicon.** Always include a branded favicon.+- **Stock "diverse team" photos.** Use real team photos, candid shots, or a consistent illustration style instead of uncanny stock imagery.++### Code Quality++- **Div soup.** Use semantic HTML: `<nav>`, `<main>`, `<article>`, `<aside>`, `<section>`.+- **Inline styles mixed with CSS classes.** Move all styling to the project's styling system.+- **Hardcoded pixel widths.** Use relative units (`%`, `rem`, `em`, `max-width`) for flexible layouts.+- **Missing alt text on images.** Describe image content for screen readers. Never leave `alt=""` or `alt="image"` on meaningful images.+- **Arbitrary z-index values like `9999`.** Establish a clean z-index scale in the theme/variables.+- **Commented-out dead code.** Remove all debug artifacts before shipping.+- **Import hallucinations.** Check that every import actually exists in `package.json` or the project dependencies.+- **Missing meta tags.** Add proper `<title>`, `description`, `og:image`, and social sharing meta tags.++### Strategic Omissions (What AI Typically Forgets)++- **No legal links.** Add privacy policy and terms of service links in the footer.+- **No "back" navigation.** Dead ends in user flows. Every page needs a way back.+- **No custom 404 page.** Design a helpful, branded "page not found" experience.+- **No form validation.** Add client-side validation for emails, required fields, and format checks.+- **No "skip to content" link.** Essential for keyboard users. Add a hidden skip-link.+- **No cookie consent.** If required by jurisdiction, add a compliant consent banner.++## Upgrade Techniques++When upgrading a project, pull from these high-impact techniques to replace generic patterns:++### Typography Upgrades+- **Variable font animation.** Interpolate weight or width on scroll or hover for text that feels alive.+- **Outlined-to-fill transitions.** Text starts as a stroke outline and fills with color on scroll entry or interaction.+- **Text mask reveals.** Large typography acting as a window to video or animated imagery behind it.++### Layout Upgrades+- **Broken grid / asymmetry.** Elements that deliberately ignore column structure — overlapping, bleeding off-screen, or offset with calculated randomness.+- **Whitespace maximization.** Aggressive use of negative space to force focus on a single element.+- **Parallax card stacks.** Sections that stick and physically stack over each other during scroll.+- **Split-screen scroll.** Two halves of the screen sliding in opposite directions.++### Motion Upgrades+- **Smooth scroll with inertia.** Decouple scrolling from browser defaults for a heavier, cinematic feel.+- **Staggered entry.** Elements cascade in with slight delays, combining Y-axis translation with opacity fade. Never mount everything at once.+- **Spring physics.** Replace linear easing with spring-based motion for a natural, weighty feel on all interactive elements.+- **Scroll-driven reveals.** Content entering through expanding masks, wipes, or draw-on SVG paths tied to scroll progress.++### Surface Upgrades+- **True glassmorphism.** Go beyond `backdrop-filter: blur`. Add a 1px inner border and a subtle inner shadow to simulate edge refraction.+- **Spotlight borders.** Card borders that illuminate dynamically under the cursor.+- **Grain and noise overlays.** A fixed, pointer-events-none overlay with subtle noise to break digital flatness.+- **Colored, tinted shadows.** Shadows that carry the hue of the background rather than using generic black.++## Fix Priority++Apply changes in this order for maximum visual impact with minimum risk:++1. **Font swap** — biggest instant improvement, lowest risk+2. **Color palette cleanup** — remove clashing or oversaturated colors+3. **Hover and active states** — makes the interface feel alive+4. **Layout and spacing** — proper grid, max-width, consistent padding+5. **Replace generic components** — swap cliche patterns for modern alternatives+6. **Add loading, empty, and error states** — makes it feel finished+7. **Polish typography scale and spacing** — the premium final touch++## Rules++- Work with the existing tech stack. Do not migrate frameworks or styling libraries.+- Do not break existing functionality. Test after every change.+- Before importing any new library, check the project's dependency file first.+- If the project uses Tailwind, check the version (v3 vs v4) before modifying config.+- If the project has no framework, use vanilla CSS.+- Keep changes reviewable and focused. Small, targeted improvements over big rewrites.diff --git a/research/README.md b/research/README.mdnew file mode 100644index 0000000..3436417--- /dev/null+++ b/research/README.md@@ -0,0 +1,8 @@+# Research++Background research that informed the skills in this project. Each topic gets its own subfolder.++## Topics++### [LLM Laziness](laziness/)+Why AI models produce incomplete outputs (placeholder code, truncated responses, skipped sections) and documented techniques to prevent it. Covers root causes, parameter fixes, prompt techniques, and experiment data.diff --git a/research/laziness/README.md b/research/laziness/README.mdnew file mode 100644index 0000000..bfea0a5--- /dev/null+++ b/research/laziness/README.md@@ -0,0 +1,25 @@+# LLM Output Truncation Research++A structured analysis of why large language models produce incomplete outputs, and documented methods to restore full-fidelity generation. All findings are drawn from controlled experiments, published studies, and field-tested engineering practices.++## Directory Structure++### Root Causes+Analysis of the economic, architectural, and behavioral mechanisms that drive output truncation in production LLMs.++- [RLHF and Compute Economics](root-causes/rlhf-and-compute.md) — How reinforcement learning and cost optimization create systematic brevity bias.+- [Training Data Bias](root-causes/training-data-bias.md) — How placeholder patterns in human-written code propagate into model outputs.+- [Cognitive Shortcuts](root-causes/cognitive-shortcuts.md) — Empirical evidence of models taking shortcuts on complex or lengthy tasks.+- [Output Limits](root-causes/output-limits.md) — Context window asymmetry and consumer-tier truncation mechanisms.++### Remediation+Documented techniques for overriding default truncation behavior, ordered from parameter-level fixes to full architectural solutions.++- [Parameter Tuning](remediation/parameter-tuning.md) — Temperature, Top-p, and Gemini thinking-level configuration.+- [Prompt Engineering](remediation/prompt-engineering.md) — Structural prompt techniques: syntax binding, XML frameworks, and verification loops.+- [Architectural Patterns](remediation/architectural-patterns.md) — MCP integration, lazy-loaded skills, and developer platform access.+- [Reference Prompts](remediation/reference-prompts.md) — Ready-to-use prompt templates for enforcing complete outputs.++### Findings+- [Empirical Results](findings/empirical-results.md) — Controlled experiment data from 2025 academic studies.+- [References](findings/references.md) — Cited studies and further reading.diff --git a/research/laziness/findings/empirical-results.md b/research/laziness/findings/empirical-results.mdnew file mode 100644index 0000000..5023f3e--- /dev/null+++ b/research/laziness/findings/empirical-results.md@@ -0,0 +1,58 @@+# Empirical Results++## 2025 Controlled Experiments++A controlled study published in December 2025 measured output truncation across several frontier models, including GPT-4 variants and DeepSeek. Three experiments were conducted:++### Experiment A: Multi-Part Instruction Compliance++Models were given complex prompts with multiple explicit requirements (formatting constraints, length requirements, mandatory sections). Results:++- No model fully satisfied both length requirements and all sub-part instructions natively+- Models frequently omitted mandatory output sections+- Required formatting constraints were routinely skipped+- Explicit length requirements were consistently undershot++### Experiment B: Decoding Suboptimality++Tested whether truncated outputs resulted from suboptimal token selection (the model "knowing" the right answer but selecting a worse token). Results:++- Limited evidence of decoding suboptimality on simple reasoning tasks+- The model's greedy, truncated output generally aligned with its highest-confidence solution+- Truncation is a deliberate behavioral choice, not a decoding failure++### Experiment C: Context Degradation++Tested whether models lose track of instructions during long, multi-turn conversations. Results:++- Surprising resilience against context degradation during 200-turn conversational tests+- Models maintained key facts and instructions significantly better than hypothesized+- Context loss is not the primary cause of truncation++### Key Conclusion++Laziness is not a failure of memory, context processing, or core model capabilities. It is a behavioral artifact triggered by:+1. Instruction complexity exceeding internal effort thresholds+2. Aggressively calibrated stopping pressure+3. Economic constraints embedded in the alignment layer++## Prompt Stimulus Effectiveness (Microsoft Research)++Controlled testing of psychological prompt stimuli documented in a Microsoft Research study:++| Stimulus | Measured Effect |+|:---|:---|+| Financial incentive framing ("$200 tip") | +45% output quality and length |+| Step-by-step instruction ("take a deep breath") | Accuracy: 34% to 80% on logic tasks |+| Stakes framing ("critical to my career") | +10% average performance |+| Combined (multiple stimuli) | Up to +115% overall performance |++These effects are reproducible and stem from statistical correlations in the training data between stakes language and high-effort human outputs.++## Seasonal Output Variation++Statistical analysis of ChatGPT outputs during November-December 2023 versus January-March 2024 confirmed:++- Measurable decrease in average output length during December+- Correlation with reduced work output in the training data during holiday periods+- Output length increased when the system prompt explicitly stated a non-winter monthdiff --git a/research/laziness/findings/references.md b/research/laziness/findings/references.mdnew file mode 100644index 0000000..fe0f291--- /dev/null+++ b/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 architecturediff --git a/research/laziness/remediation/architectural-patterns.md b/research/laziness/remediation/architectural-patterns.mdnew file mode 100644index 0000000..eb58186--- /dev/null+++ b/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.diff --git a/research/laziness/remediation/parameter-tuning.md b/research/laziness/remediation/parameter-tuning.mdnew file mode 100644index 0000000..5bf2a25--- /dev/null+++ b/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.diff --git a/research/laziness/remediation/prompt-engineering.md b/research/laziness/remediation/prompt-engineering.mdnew file mode 100644index 0000000..9f3704b--- /dev/null+++ b/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 metdiff --git a/research/laziness/remediation/reference-prompts.md b/research/laziness/remediation/reference-prompts.mdnew file mode 100644index 0000000..185ad86--- /dev/null+++ b/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.+```diff --git a/research/laziness/root-causes/cognitive-shortcuts.md b/research/laziness/root-causes/cognitive-shortcuts.mdnew file mode 100644index 0000000..ad67fa1--- /dev/null+++ b/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.diff --git a/research/laziness/root-causes/output-limits.md b/research/laziness/root-causes/output-limits.mdnew file mode 100644index 0000000..3d346ef--- /dev/null+++ b/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 |diff --git a/research/laziness/root-causes/rlhf-and-compute.md b/research/laziness/root-causes/rlhf-and-compute.mdnew file mode 100644index 0000000..5ef6783--- /dev/null+++ b/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.diff --git a/research/laziness/root-causes/training-data-bias.md b/research/laziness/root-causes/training-data-bias.mdnew file mode 100644index 0000000..1aa2c7a--- /dev/null+++ b/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.diff --git a/SKILL.md b/taste-skill/SKILL.mdsimilarity index 99%rename from SKILL.mdrename to taste-skill/SKILL.mdindex 0cecccb..ccc3a2f 100644--- a/SKILL.md+++ b/taste-skill/SKILL.md@@ -94,7 +94,7 @@ To actively combat generic AI designs, systematically implement these high-end c* **4-7 (Daily App Mode):** Normal spacing for standard web apps.* **8-10 (Cockpit Mode):** Tiny paddings. No card boxes; just 1px lines to separate data. Everything is packed. **Mandatory:** Use Monospace (`font-mono`) for all numbers.-## 7. THE 100 AI TELLS (Forbidden Patterns)+## 7. AI TELLS (Forbidden Patterns)To guarantee a premium, non-generic output, you MUST strictly avoid these common AI design signatures unless explicitly requested:### Visual & CSS