research-copilot 0.1.0

package/lib/skills/builtin/creative-thinking-for-research/SKILL.md

@@ -0,0 +1,273 @@
+---
+name: creative-thinking-for-research
+description: Eight cognitive science frameworks for generating genuinely novel research directions. Use when stuck in a local optimum, when brainstorming-research-ideas alone yields only incremental candidates, or when you need deeper cognitive disruption.
+category: Research Ideation
+depends: [brainstorming-research-ideas]
+tags: [Creative Thinking, Research Ideation, Analogical Reasoning, Problem Reformulation, Cognitive Science]
+triggers: [creative thinking, novel ideas, think outside the box, stuck, local optimum, breakthrough, 创新思维, 跳出框架, 创造性思考]
+---
+
+# Creative Thinking for Research
+
+Eight empirically grounded frameworks from cognitive science, applied to CS and AI research. Unlike ad-hoc brainstorming, each framework is backed by decades of creativity research — from Koestler's bisociation to Kauffman's adjacent possible. They target distinct cognitive operations: combining, reformulating, analogizing, constraining, inverting, abstracting, exploring boundaries, and holding contradictions.
+
+## Overview
+
+This skill provides deeper cognitive engines for generating truly novel research directions. While `brainstorming-research-ideas` provides operational workflows (diverge → converge → refine) and practical filters, this skill provides the cognitive frameworks that power creative leaps. Use them together: creative-thinking to generate raw insight, brainstorming-research-ideas to structure and evaluate it.
+
+## When to Use This Skill
+
+- The `brainstorming-research-ideas` skill produced only incremental candidates — you need deeper cognitive disruption.
+- Multiple sessions of investigation have produced diminishing returns — you may be stuck in a local optimum.
+- The user explicitly asked for "novel" or "creative" directions.
+- You need to justify a significant pivot in research focus.
+
+**Do NOT use this skill when**:
+- You need structured project-level brainstorming workflows — use `brainstorming-research-ideas` instead.
+- You have a well-defined research question and need execution guidance — proceed with normal task execution.
+- You need a literature survey — use the `literature-search` tool directly.
+
+---
+
+## Framework 1: Combinatorial Creativity (Bisociation)
+
+Novel ideas arise from combining existing concepts in unexpected ways. Arthur Koestler called this **bisociation** — connecting two previously unrelated frames of reference, distinct from routine association within a single frame.
+
+**Why it works**: Meta-research consistently shows that breadth of knowledge is a precursor to creative output. The combination itself is the creative act.
+
+**Systematic Bisociation Workflow**:
+
+1. **Select two domains** — one from current research, one from an adjacent field
+2. **List core primitives** in each domain (5-10 fundamental concepts per domain)
+3. **Create a cross-product matrix**: row = concepts from Domain A, column = concepts from Domain B
+4. **For each cell**, ask: "What would it mean to apply A's concept to B's problem?"
+5. **Filter**: Which combinations produce a non-trivial, testable research question?
+6. **Validate structural depth**: Is the connection mechanistic or merely metaphorical?
+
+**Cross-Product Example**:
+
+| | Caching | Load Balancing | Fault Tolerance |
+|---|---------|---------------|-----------------|
+| **Natural Selection** | Evict least-fit entries | Adaptive allocation via fitness | Population-level redundancy |
+| **Immune Memory** | Learned threat signatures | Distributed detection | Self/non-self discrimination |
+| **Symbiosis** | Cooperative prefetching | Mutualistic resource sharing | Co-dependent resilience |
+
+**Quality Test**: A strong bisociation is not a surface metaphor ("the network is like a brain") but a structural mapping where the mechanism transfers ("attention mechanisms implement selective gating analogous to cognitive attention filtering").
+
+---
+
+## Framework 2: Problem Reformulation (Representational Change)
+
+Gestalt psychologists identified that breakthroughs often come not from solving the problem as stated, but from **re-representing the problem itself**. Kaplan and Simon's work on insight shows that changing the problem space is often where creativity lives.
+
+**The Key Shift**: From "How do I solve this problem?" to "Am I even thinking about this problem correctly?"
+
+**Reformulation Strategies**:
+
+| Strategy | Example |
+|----------|---------|
+| **Change the objective** | "Make the algorithm faster" → "Eliminate the need for this computation" |
+| **Change the formalism** | Graph problem → linear algebra problem (spectral methods) |
+| **Change the granularity** | Per-token prediction → per-span prediction |
+| **Change the agent** | "How should the model learn?" → "How should the data teach?" (curriculum learning) |
+| **Change the timescale** | Real-time optimization → amortized inference |
+| **Invert the direction** | Forward simulation → inverse problem (learning from observations) |
+
+**Application**: State your current research problem in one sentence. Identify the hidden assumptions — formalism, objective, granularity, agent. For each assumption, generate the alternative: "What if [opposite]?" A reformulation that makes a hard problem easy is often a publishable insight.
+
+**Classic CS Examples**:
+- **PageRank**: Reformulated "find important pages" from content analysis to graph eigenvalue problem
+- **Dropout**: Reformulated "prevent overfitting" from regularization to approximate ensemble
+- **Attention**: Reformulated "handle long sequences" from remembering everything to selectively querying
+
+---
+
+## Framework 3: Analogical Reasoning (Structure-Mapping)
+
+Dedre Gentner's **structure-mapping theory**: surface-level analogies are common but weak; **structural or relational analogies** — where the deep causal structure maps across domains — produce the most powerful insights.
+
+**Levels of Analogical Depth**:
+
+| Level | Description | Value | Example |
+|-------|-------------|-------|---------|
+| **Surface** | Things look similar | Low | "A neural network is like a brain" |
+| **Relational** | Relationships between entities match | Medium | "Attention allocation parallels economic resource allocation" |
+| **Structural** | Deep causal mechanisms map | High | "Diffusion models reverse thermodynamic processes; stat-mech math directly applies" |
+
+**Structure-Mapping Workflow**:
+
+1. **Describe your problem** using only relational/causal language (strip domain-specific nouns)
+2. **Search for structural matches**: What other systems solve a structurally similar problem? Use the `literature-search` tool to search the source domain.
+3. **Pick the most distant match** with genuine structural fidelity
+4. **Map the solution mechanism**: How does the source domain solve this?
+5. **Transfer and adapt**: What changes when you bring that mechanism into your domain?
+6. **Generate predictions**: The analogy should tell you something you didn't already know — formulate as a concrete validation experiment
+
+---
+
+## Framework 4: Constraint Manipulation (Boden's Framework)
+
+Margaret Boden's framework distinguishes three forms of creativity:
+
+| Type | Operation | CS Example |
+|------|-----------|------------|
+| **Exploratory** | Search within the existing conceptual space | Hyperparameter tuning, architecture search within a fixed paradigm |
+| **Combinational** | Combine elements from different spaces | Multi-task learning, neuro-symbolic methods |
+| **Transformational** | Change the rules of the space itself | Dropping the assumption that training requires labels (self-supervised learning) |
+
+**Transformational creativity is the rarest and highest-impact.** It happens when you change what is even considered a valid solution.
+
+**Constraint Analysis Workflow**:
+
+1. **List the constraints** of your current approach (5-10):
+   - Computational, Methodological, Architectural, Evaluative
+2. **Classify each**:
+   - **Hard**: Physically or logically necessary (cannot violate)
+   - **Soft**: Convention or historical accident (can question)
+   - **Hidden**: Not stated but implicitly assumed (most fertile for innovation)
+3. **For each soft/hidden constraint**: What if relaxed? What if tightened? What if replaced entirely?
+4. **The most productive move** is often exposing and dropping a hidden constraint
+
+**Classic Constraint Transformations**:
+- "Data must fit in memory" → dropped → streaming algorithms, external memory
+- "Training requires human labels" → dropped → self-supervised learning
+- "Models must be deterministic" → dropped → variational methods, diffusion
+- "Inference must happen in one pass" → dropped → iterative refinement, chain-of-thought
+
+---
+
+## Framework 5: Negation and Inversion
+
+Take a core assumption and negate it. Formalized in De Bono's lateral thinking and the **TRIZ methodology**.
+
+**The Pattern**: "What if [widely held assumption] is wrong, unnecessary, or invertible?"
+
+**Systematic Negation Workflow**:
+
+1. **List 5-10 core assumptions** in the current research area (the things "everyone knows")
+2. **Negate each one** and ask: What system would you build?
+3. **Evaluate each negation**:
+   - Incoherent → discard
+   - Already explored → use `literature-search` to check if conditions have changed
+   - Unexplored and coherent → candidate research direction
+
+**Negation Hall of Fame in CS**:
+
+| Assumption | Negation | Result |
+|-----------|----------|--------|
+| "We need strong consistency" | What if we don't? | Eventual consistency, CRDTs |
+| "We need exact answers" | What if approximate is fine? | Sketches, LSH, approximate nearest neighbors |
+| "Labels are necessary" | What if we learn without them? | Self-supervised learning, contrastive methods |
+| "More parameters = more compute" | What if we don't use all parameters? | Mixture of Experts, sparse models |
+| "Training and inference are separate" | What if the model keeps learning? | Online learning, test-time training |
+| "Errors must be prevented" | What if we embrace and correct them? | Speculative decoding, self-correction |
+
+**TRIZ-Inspired Principles for CS**:
+
+| TRIZ Principle | CS Application |
+|---------------|----------------|
+| **Inversion** | Reverse the process (generative vs. discriminative) |
+| **Segmentation** | Break monolithic into modular (microservices, mixture of experts) |
+| **Merging** | Combine separate steps (end-to-end learning) |
+| **Universality** | One component serves multiple functions (multi-task models) |
+| **Nesting** | Place one system inside another (meta-learning) |
+| **Dynamization** | Make static things adaptive (dynamic architectures, adaptive computation) |
+
+---
+
+## Framework 6: Abstraction and Generalization Laddering
+
+Moving up and down the abstraction ladder is a fundamental creative act. Polya's heuristics: *"Can you solve a more general problem? A more specific one? An analogous one?"*
+
+| Move | Question | Outcome |
+|------|----------|---------|
+| **Generalize** | "Is my solution a special case of something broader?" | Framework papers, unifying theories |
+| **Specialize** | "What happens when I add extreme constraints?" | Niche applications, surprising edge cases |
+| **Analogize** | "Where else does this abstract pattern appear?" | Cross-domain transfer (see Framework 3) |
+
+**Application**: For any research finding, replace each specific element with a variable. Ask: under what conditions does this hold? If the general principle is novel → that is the contribution. Specialization under extreme constraints reveals the method's true assumptions — failures become key validation questions.
+
+---
+
+## Framework 7: The Adjacent Possible (Kauffman / Johnson)
+
+Stuart Kauffman's concept: innovation happens at the boundary of what is currently reachable — the **adjacent possible**. New ideas become thinkable once their prerequisites exist.
+
+**Adjacent Possible Mapping Workflow**:
+
+1. **List recent enablers** (use `literature-search` and `web-search` to surface these):
+   - New hardware capabilities (longer context, faster inference, new accelerators)
+   - New datasets or benchmarks
+   - New open-source tools or frameworks
+   - New theoretical results
+   - New regulatory or social conditions
+2. **For each enabler, ask**: "What was previously impossible or impractical that this now permits?"
+3. **Combine enablers**: The most powerful adjacent possibles arise from the intersection of multiple new enablers
+4. **Check for competition**: If many groups can see the same adjacent possible, speed or a unique angle matters
+
+**Timing Signal**: If the idea requires technology that doesn't exist yet → beyond the adjacent possible, park it. If the idea could have been done 3+ years ago → someone probably did, check the literature. The sweet spot is ideas that became feasible in the last 6-18 months.
+
+---
+
+## Framework 8: Janusian and Dialectical Thinking
+
+Albert Rothenberg's studies of eminent creators: **holding two contradictory ideas simultaneously** is a hallmark of creative thinking. This mode doesn't resolve contradictions by choosing a side — it generates new frameworks that transcend the opposition.
+
+| Contradiction | Resolution | Impact |
+|--------------|------------|--------|
+| Consistency AND Availability | CAP theorem + practical middle grounds (Raft, CRDTs) | Foundation of distributed systems |
+| Security AND Usability | Zero-knowledge proofs | Enabled private computation |
+| Expressiveness AND Tractability | Probabilistic programming | New programming paradigm |
+| Memorization AND Generalization | Grokking | New understanding of learning dynamics |
+| Compression AND Quality | Neural codecs with learned priors | Redefined compression research |
+
+**Dialectical Thinking Workflow**:
+
+1. **Identify a binary** in your research area: A vs. B (two approaches, goals, or paradigms treated as opposites)
+2. **Resist choosing a side**. Instead ask:
+   - "What would a system look like that achieves both A and B?"
+   - "Under what conditions is the A-B trade-off not fundamental?"
+   - "Is the opposition an artifact of how we formalized the problem?"
+3. **Seek synthesis**: The resolution often requires a new abstraction that reframes the relationship
+4. **Test the synthesis**: Formulate as a concrete experiment — can you demonstrate empirically that both goals are achievable?
+
+---
+
+## Combined Creative Thinking Protocol
+
+These frameworks are most powerful in combination. Use this protocol for deep creative thinking when individual lenses are insufficient.
+
+### Phase 1: Map the Space
+1. **Constraint Manipulation** (F4): List all constraints of the current paradigm. Mark which are hard, soft, hidden.
+2. **Adjacent Possible** (F7): Use `literature-search` and `web-search` to list recent enablers that change the feasibility landscape.
+
+Save the constraint map and enabler list as note artifacts.
+
+### Phase 2: Generate Disruptions
+3. **Negation** (F5): Negate 3 soft/hidden constraints. What systems emerge?
+4. **Bisociation** (F1): Pick a distant field and create a cross-product matrix with your domain.
+5. **Problem Reformulation** (F2): Restate your problem 3 different ways (change objective, formalism, agent).
+
+### Phase 3: Deepen Promising Leads
+6. **Analogical Reasoning** (F3): For each promising idea, find a structural analogy and extract predictions.
+7. **Abstraction Laddering** (F6): Move each idea up (generalize) and down (specialize).
+8. **Janusian Thinking** (F8): Identify any tensions. Can you synthesize rather than choose?
+
+### Phase 4: Evaluate
+Apply the two-sentence test (from `brainstorming-research-ideas`, Framework 10):
+> "**[Domain] currently struggles with [problem] because [reason].** We [approach] by [mechanism], which works because [insight]."
+
+Any idea that survives all four phases → present to the user as a refined research direction with concrete next steps.
+
+---
+
+## Common Creative Blocks and Unblocking Strategies
+
+| Block | Symptom | Framework to Apply |
+|-------|---------|-------------------|
+| **Fixation** | Cannot stop thinking about the problem one way | Problem Reformulation (F2) — force a different representation |
+| **Tunnel vision** | All ideas come from the same literature cluster | Bisociation (F1) or Analogical Reasoning (F3) — import from elsewhere |
+| **Self-censoring** | Dismissing ideas as implausible before exploring | Negation (F5) — implausible is the point; evaluate after generating |
+| **Incrementalism** | Every candidate is "+2% on benchmark X" | Constraint Manipulation (F4) — change the rules, not the parameters |
+| **Analysis paralysis** | Too many options, cannot commit a direction | Adjacent Possible (F7) — what is feasible right now given project constraints? |
+| **False dichotomy** | Stuck choosing between two approaches | Janusian Thinking (F8) — seek synthesis, not selection |

package/lib/skills/builtin/matplotlib/SKILL.md

@@ -0,0 +1,361 @@
+---
+name: matplotlib
+description: Low-level plotting library for full customization. Use when you need fine-grained control over every plot element, creating novel plot types, or integrating with specific scientific workflows. Export to PNG/PDF/SVG for publication. For quick statistical plots use seaborn; for interactive plots use plotly; for publication-ready multi-panel figures with journal styling, use scientific-visualization.
+category: Visualization
+tags: [science, visualization]
+triggers: [matplotlib, plt.plot, custom plot, plot from scratch, fine-grained plot control]
+license: https://github.com/matplotlib/matplotlib/tree/main/LICENSE
+metadata:
+    skill-author: K-Dense Inc.
+---
+
+# Matplotlib
+
+## Overview
+
+Matplotlib is Python's foundational visualization library for creating static, animated, and interactive plots. This skill provides guidance on using matplotlib effectively, covering both the pyplot interface (MATLAB-style) and the object-oriented API (Figure/Axes), along with best practices for creating publication-quality visualizations.
+
+## When to Use This Skill
+
+This skill should be used when:
+- Creating any type of plot or chart (line, scatter, bar, histogram, heatmap, contour, etc.)
+- Generating scientific or statistical visualizations
+- Customizing plot appearance (colors, styles, labels, legends)
+- Creating multi-panel figures with subplots
+- Exporting visualizations to various formats (PNG, PDF, SVG, etc.)
+- Building interactive plots or animations
+- Working with 3D visualizations
+- Integrating plots into Jupyter notebooks or GUI applications
+
+## Core Concepts
+
+### The Matplotlib Hierarchy
+
+Matplotlib uses a hierarchical structure of objects:
+
+1. **Figure** - The top-level container for all plot elements
+2. **Axes** - The actual plotting area where data is displayed (one Figure can contain multiple Axes)
+3. **Artist** - Everything visible on the figure (lines, text, ticks, etc.)
+4. **Axis** - The number line objects (x-axis, y-axis) that handle ticks and labels
+
+### Two Interfaces
+
+**1. pyplot Interface (Implicit, MATLAB-style)**
+```python
+import matplotlib.pyplot as plt
+
+plt.plot([1, 2, 3, 4])
+plt.ylabel('some numbers')
+plt.show()
+```
+- Convenient for quick, simple plots
+- Maintains state automatically
+- Good for interactive work and simple scripts
+
+**2. Object-Oriented Interface (Explicit)**
+```python
+import matplotlib.pyplot as plt
+
+fig, ax = plt.subplots()
+ax.plot([1, 2, 3, 4])
+ax.set_ylabel('some numbers')
+plt.show()
+```
+- **Recommended for most use cases**
+- More explicit control over figure and axes
+- Better for complex figures with multiple subplots
+- Easier to maintain and debug
+
+## Common Workflows
+
+### 1. Basic Plot Creation
+
+**Single plot workflow:**
+```python
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Create figure and axes (OO interface - RECOMMENDED)
+fig, ax = plt.subplots(figsize=(10, 6))
+
+# Generate and plot data
+x = np.linspace(0, 2*np.pi, 100)
+ax.plot(x, np.sin(x), label='sin(x)')
+ax.plot(x, np.cos(x), label='cos(x)')
+
+# Customize
+ax.set_xlabel('x')
+ax.set_ylabel('y')
+ax.set_title('Trigonometric Functions')
+ax.legend()
+ax.grid(True, alpha=0.3)
+
+# Save and/or display
+plt.savefig('plot.png', dpi=300, bbox_inches='tight')
+plt.show()
+```
+
+### 2. Multiple Subplots
+
+**Creating subplot layouts:**
+```python
+# Method 1: Regular grid
+fig, axes = plt.subplots(2, 2, figsize=(12, 10))
+axes[0, 0].plot(x, y1)
+axes[0, 1].scatter(x, y2)
+axes[1, 0].bar(categories, values)
+axes[1, 1].hist(data, bins=30)
+
+# Method 2: Mosaic layout (more flexible)
+fig, axes = plt.subplot_mosaic([['left', 'right_top'],
+                                 ['left', 'right_bottom']],
+                                figsize=(10, 8))
+axes['left'].plot(x, y)
+axes['right_top'].scatter(x, y)
+axes['right_bottom'].hist(data)
+
+# Method 3: GridSpec (maximum control)
+from matplotlib.gridspec import GridSpec
+fig = plt.figure(figsize=(12, 8))
+gs = GridSpec(3, 3, figure=fig)
+ax1 = fig.add_subplot(gs[0, :])  # Top row, all columns
+ax2 = fig.add_subplot(gs[1:, 0])  # Bottom two rows, first column
+ax3 = fig.add_subplot(gs[1:, 1:])  # Bottom two rows, last two columns
+```
+
+### 3. Plot Types and Use Cases
+
+**Line plots** - Time series, continuous data, trends
+```python
+ax.plot(x, y, linewidth=2, linestyle='--', marker='o', color='blue')
+```
+
+**Scatter plots** - Relationships between variables, correlations
+```python
+ax.scatter(x, y, s=sizes, c=colors, alpha=0.6, cmap='viridis')
+```
+
+**Bar charts** - Categorical comparisons
+```python
+ax.bar(categories, values, color='steelblue', edgecolor='black')
+# For horizontal bars:
+ax.barh(categories, values)
+```
+
+**Histograms** - Distributions
+```python
+ax.hist(data, bins=30, edgecolor='black', alpha=0.7)
+```
+
+**Heatmaps** - Matrix data, correlations
+```python
+im = ax.imshow(matrix, cmap='coolwarm', aspect='auto')
+plt.colorbar(im, ax=ax)
+```
+
+**Contour plots** - 3D data on 2D plane
+```python
+contour = ax.contour(X, Y, Z, levels=10)
+ax.clabel(contour, inline=True, fontsize=8)
+```
+
+**Box plots** - Statistical distributions
+```python
+ax.boxplot([data1, data2, data3], labels=['A', 'B', 'C'])
+```
+
+**Violin plots** - Distribution densities
+```python
+ax.violinplot([data1, data2, data3], positions=[1, 2, 3])
+```
+
+For comprehensive plot type examples and variations, refer to `@skill/references/plot_types.md`.
+
+### 4. Styling and Customization
+
+**Color specification methods:**
+- Named colors: `'red'`, `'blue'`, `'steelblue'`
+- Hex codes: `'#FF5733'`
+- RGB tuples: `(0.1, 0.2, 0.3)`
+- Colormaps: `cmap='viridis'`, `cmap='plasma'`, `cmap='coolwarm'`
+
+**Using style sheets:**
+```python
+plt.style.use('seaborn-v0_8-darkgrid')  # Apply predefined style
+# Available styles: 'ggplot', 'bmh', 'fivethirtyeight', etc.
+print(plt.style.available)  # List all available styles
+```
+
+**Customizing with rcParams:**
+```python
+plt.rcParams['font.size'] = 12
+plt.rcParams['axes.labelsize'] = 14
+plt.rcParams['axes.titlesize'] = 16
+plt.rcParams['xtick.labelsize'] = 10
+plt.rcParams['ytick.labelsize'] = 10
+plt.rcParams['legend.fontsize'] = 12
+plt.rcParams['figure.titlesize'] = 18
+```
+
+**Text and annotations:**
+```python
+ax.text(x, y, 'annotation', fontsize=12, ha='center')
+ax.annotate('important point', xy=(x, y), xytext=(x+1, y+1),
+            arrowprops=dict(arrowstyle='->', color='red'))
+```
+
+For detailed styling options and colormap guidelines, see `@skill/references/styling_guide.md`.
+
+### 5. Saving Figures
+
+**Export to various formats:**
+```python
+# High-resolution PNG for presentations/papers
+plt.savefig('figure.png', dpi=300, bbox_inches='tight', facecolor='white')
+
+# Vector format for publications (scalable)
+plt.savefig('figure.pdf', bbox_inches='tight')
+plt.savefig('figure.svg', bbox_inches='tight')
+
+# Transparent background
+plt.savefig('figure.png', dpi=300, bbox_inches='tight', transparent=True)
+```
+
+**Important parameters:**
+- `dpi`: Resolution (300 for publications, 150 for web, 72 for screen)
+- `bbox_inches='tight'`: Removes excess whitespace
+- `facecolor='white'`: Ensures white background (useful for transparent themes)
+- `transparent=True`: Transparent background
+
+### 6. Working with 3D Plots
+
+```python
+from mpl_toolkits.mplot3d import Axes3D
+
+fig = plt.figure(figsize=(10, 8))
+ax = fig.add_subplot(111, projection='3d')
+
+# Surface plot
+ax.plot_surface(X, Y, Z, cmap='viridis')
+
+# 3D scatter
+ax.scatter(x, y, z, c=colors, marker='o')
+
+# 3D line plot
+ax.plot(x, y, z, linewidth=2)
+
+# Labels
+ax.set_xlabel('X Label')
+ax.set_ylabel('Y Label')
+ax.set_zlabel('Z Label')
+```
+
+## Best Practices
+
+### 1. Interface Selection
+- **Use the object-oriented interface** (fig, ax = plt.subplots()) for production code
+- Reserve pyplot interface for quick interactive exploration only
+- Always create figures explicitly rather than relying on implicit state
+
+### 2. Figure Size and DPI
+- Set figsize at creation: `fig, ax = plt.subplots(figsize=(10, 6))`
+- Use appropriate DPI for output medium:
+  - Screen/notebook: 72-100 dpi
+  - Web: 150 dpi
+  - Print/publications: 300 dpi
+
+### 3. Layout Management
+- Use `constrained_layout=True` or `tight_layout()` to prevent overlapping elements
+- `fig, ax = plt.subplots(constrained_layout=True)` is recommended for automatic spacing
+
+### 4. Colormap Selection
+- **Sequential** (viridis, plasma, inferno): Ordered data with consistent progression
+- **Diverging** (coolwarm, RdBu): Data with meaningful center point (e.g., zero)
+- **Qualitative** (tab10, Set3): Categorical/nominal data
+- Avoid rainbow colormaps (jet) - they are not perceptually uniform
+
+### 5. Accessibility
+- Use colorblind-friendly colormaps (viridis, cividis)
+- Add patterns/hatching for bar charts in addition to colors
+- Ensure sufficient contrast between elements
+- Include descriptive labels and legends
+
+### 6. Performance
+- For large datasets, use `rasterized=True` in plot calls to reduce file size
+- Use appropriate data reduction before plotting (e.g., downsample dense time series)
+- For animations, use blitting for better performance
+
+### 7. Code Organization
+```python
+# Good practice: Clear structure
+def create_analysis_plot(data, title):
+    """Create standardized analysis plot."""
+    fig, ax = plt.subplots(figsize=(10, 6), constrained_layout=True)
+
+    # Plot data
+    ax.plot(data['x'], data['y'], linewidth=2)
+
+    # Customize
+    ax.set_xlabel('X Axis Label', fontsize=12)
+    ax.set_ylabel('Y Axis Label', fontsize=12)
+    ax.set_title(title, fontsize=14, fontweight='bold')
+    ax.grid(True, alpha=0.3)
+
+    return fig, ax
+
+# Use the function
+fig, ax = create_analysis_plot(my_data, 'My Analysis')
+plt.savefig('analysis.png', dpi=300, bbox_inches='tight')
+```
+
+## Quick Reference Scripts
+
+This skill includes helper scripts in the `@skill/scripts/` directory:
+
+### `plot_template.py`
+Template script demonstrating various plot types with best practices. Use this as a starting point for creating new visualizations.
+
+**Usage:**
+```bash
+python @skill/scripts/plot_template.py
+```
+
+### `style_configurator.py`
+Interactive utility to configure matplotlib style preferences and generate custom style sheets.
+
+**Usage:**
+```bash
+python @skill/scripts/style_configurator.py
+```
+
+## Detailed References
+
+For comprehensive information, consult the reference documents:
+
+- **`@skill/references/plot_types.md`** - Complete catalog of plot types with code examples and use cases
+- **`@skill/references/styling_guide.md`** - Detailed styling options, colormaps, and customization
+- **`@skill/references/api_reference.md`** - Core classes and methods reference
+- **`@skill/references/common_issues.md`** - Troubleshooting guide for common problems
+
+## Integration with Other Tools
+
+Matplotlib integrates well with:
+- **NumPy/Pandas** - Direct plotting from arrays and DataFrames
+- **Seaborn** - High-level statistical visualizations built on matplotlib
+- **Jupyter** - Interactive plotting with `%matplotlib inline` or `%matplotlib widget`
+- **GUI frameworks** - Embedding in Tkinter, Qt, wxPython applications
+
+## Common Gotchas
+
+1. **Overlapping elements**: Use `constrained_layout=True` or `tight_layout()`
+2. **State confusion**: Use OO interface to avoid pyplot state machine issues
+3. **Memory issues with many figures**: Close figures explicitly with `plt.close(fig)`
+4. **Font warnings**: Install fonts or suppress warnings with `plt.rcParams['font.sans-serif']`
+5. **DPI confusion**: Remember that figsize is in inches, not pixels: `pixels = dpi * inches`
+
+## Additional Resources
+
+- Official documentation: https://matplotlib.org/
+- Gallery: https://matplotlib.org/stable/gallery/index.html
+- Cheatsheets: https://matplotlib.org/cheatsheets/
+- Tutorials: https://matplotlib.org/stable/tutorials/index.html