Initial import from GitHub

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.

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 |

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.

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.