pi-skill-search 0.1.0

package/skills/iso-13485-certification/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: iso-13485-certification
+description: Comprehensive toolkit for preparing ISO 13485 certification documentation for medical device Quality Management Systems. Use when users need help with ISO 13485 QMS documentation, including (1) conducting gap analysis of existing documentation, (2) creating Quality Manuals, (3) developing required procedures and work instructions, (4) preparing Medical Device Files, (5) understanding ISO 13485 requirements, or (6) identifying missing documentation for medical device certification. Also use when users mention medical device regulations, QMS certification, FDA QMSR, EU MDR, or need help with quality system documentation.
+---
+
+# ISO 13485 Certification Documentation Assistant
+
+## Overview
+
+This skill helps medical device manufacturers prepare comprehensive documentation for ISO 13485:2016 certification. It provides tools, templates, references, and guidance to create, review, and gap-analyze all required Quality Management System (QMS) documentation.
+
+**What this skill provides:**
+- Gap analysis of existing documentation
+- Templates for all mandatory documents
+- Comprehensive requirements guidance
+- Step-by-step documentation creation
+- Identification of missing documentation
+- Compliance checklists
+
+**When to use this skill:**
+- Starting ISO 13485 certification process
+- Conducting gap analysis against ISO 13485
+
+## Core Workflow
+
+### 1. Assess Current State (Gap Analysis)
+
+**When to start here:** User has existing documentation and needs to identify gaps
+
+**Process:**
+
+1. **Collect existing documentation:**
+   - Ask user to provide directory of current QMS documents
+   - Documents can be in any format (.txt, .md, .doc, .docx, .pdf)
+   - Include any procedures, manuals, work instructions, forms
+
+2. **Run gap analysis script:**
+   ```bash
+   python scripts/gap_analyzer.py --docs-dir <path_to_docs> --output gap-report.json
+   ```
+
+### 2. Understand Requirements (Reference Consultation)
+
+**When to use:** User needs to understand specific ISO 13485 requirements
+
+**Available references:**
+- `(see docs)` - Complete clause-by-clause breakdown
+- `(see docs)` - All 31 required procedures explained
+- `(see docs)` - Detailed compliance checklist
+- `(see docs)` - How to create Quality Manual
+
+**How to use:**
+
+1. **For specific clause questions:**
+   - Read relevant section from `iso-13485-requirements.md`
+   - Explain requirements in plain language
+
+### 3. Create Documentation (Template-Based Generation)
+
+**When to use:** User needs to create specific QMS documents
+
+**Available templates:**
+- Quality Manual: `assets/templates/quality-manual-template.md`
+- CAPA Procedure: `assets/templates/procedures/CAPA-procedure-template.md`
+- Document Control: `assets/templates/procedures/document-control-procedure-template.md`
+
+**Process for document creation:**
+
+1. **Identify what needs to be created:**
+   - Based on gap analysis or user request
+   - Prioritize critical documents first (Quality Manual, CAPA, Complaints, Audits)
+
+### 4. Develop Specific Documents
+
+#### Creating a Quality Manual
+
+**Process:**
+
+1. **Read the comprehensive guide:**
+   - Read `(see docs)` in full
+   - Understand structure and required content
+   - Review examples provided
+
+2. **Gather organization information:**
+   - Legal company name and addresses
+   - Product types and classifications
+   - Organizational structure
+
+### 5. Conduct Comprehensive Gap Analysis
+
+**When to use:** User wants detailed assessment of all requirements
+
+**Process:**
+
+1. **Use comprehensive checklist:**
+   - Open `(see docs)`
+   - Work through clause by clause
+   - Mark status for each requirement: Compliant, Partial, Non-compliant, N/A
+
+2. **For each clause:**
+   - Read requirement description
+   - Identify existing evidence
+   - Note gaps or deficiencies
+
+## Common Scenarios
+
+### Scenario 1: Starting from Scratch
+
+**User request:** "We're a medical device startup and need to implement ISO 13485. Where do we start?"
+
+**Approach:**
+
+1. **Explain the journey:**
+

package/skills/knowledge-agent/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: knowledge-agent
+description: Build and query AI-powered knowledge bases from claude-mem observations. Use when users want to create focused "brains" from their observation history, ask questions about past work patterns, or compile expertise on specific topics.
+---
+
+# Knowledge Agent
+
+Build and query AI-powered knowledge bases from claude-mem observations.
+
+## What Are Knowledge Agents?
+
+Knowledge agents are filtered corpora of observations compiled into a conversational AI session. Build a corpus from your observation history, prime it (loads the knowledge into an AI session), then ask it questions conversationally.
+
+Think of them as custom "brains": "everything about hooks", "all decisions from the last month", "all bugfixes for the worker service".
+
+## Workflow
+
+### Step 1: Build a corpus
+
+```text
+build_corpus name="hooks-expertise" description="Everything about the hooks lifecycle" project="claude-mem" concepts="hooks" limit=500
+```
+
+Filter options:
+- `project` — filter by project name
+- `types` — comma-separated: decision, bugfix, feature, refactor, discovery, change
+- `concepts` — comma-separated concept tags
+- `files` — comma-separated file paths (prefix match)
+- `query` — semantic search query
+- `dateStart` / `dateEnd` — ISO date range
+- `limit` — max observations (default 500)
+
+### Step 2: Prime the corpus
+
+```text
+prime_corpus name="hooks-expertise"
+```
+
+This creates an AI session loaded with all the corpus knowledge. Takes a moment for large corpora.
+
+### Step 3: Query
+
+```text
+query_corpus name="hooks-expertise" question="What are the 5 lifecycle hooks and when does each fire?"
+```
+
+The knowledge agent answers from its corpus. Follow-up questions maintain context.
+
+### Step 4: List corpora
+
+```text
+list_corpora
+```
+
+Shows all corpora with stats and priming status.
+
+## Tips
+
+- **Focused corpora work best** — "hooks architecture" beats "everything ever"
+- **Prime once, query many times** — the session persists across queries
+- **Reprime for fresh context** — if the conversation drifts, reprime to reset
+- **Rebuild to update** — when new observations are added, rebuild then reprime
+
+## Maintenance
+
+### Rebuild a corpus (refresh with new observations)
+
+```text
+rebuild_corpus name="hooks-expertise"
+```
+
+After rebuilding, reprime to load the updated knowledge:
+
+### Reprime (fresh session)
+
+```text
+reprime_corpus name="hooks-expertise"
+```
+
+Clears prior Q&A context and reloads the corpus into a new session.
+
+
+

package/skills/labarchive-integration/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: labarchive-integration
+description: Electronic lab notebook API integration. Access notebooks, manage entries/attachments, backup notebooks, integrate with Protocols.io/Jupyter/REDCap, for programmatic ELN workflows.
+---
+
+# LabArchives Integration
+
+## Overview
+
+LabArchives is an electronic lab notebook platform for research documentation and data management. Access notebooks, manage entries and attachments, generate reports, and integrate with third-party tools programmatically via REST API.
+
+## When to Use This Skill
+
+This skill should be used when:
+- Working with LabArchives REST API for notebook automation
+- Backing up notebooks programmatically
+- Creating or managing notebook entries and attachments
+- Generating site reports and analytics
+- Integrating LabArchives with third-party tools (Protocols.io, Jupyter, REDCap)
+- Automating data upload to electronic lab notebooks
+- Managing user access and permissions programmatically
+
+## Core Capabilities
+
+### 1. Authentication and Configuration
+
+Set up API access credentials and regional endpoints for LabArchives API integration.
+
+**Prerequisites:**
+- Enterprise LabArchives license with API access enabled
+- API access key ID and password from LabArchives administrator
+- User authentication credentials (email and external applications password)
+
+**Configuration setup:**
+
+Use the `scripts/setup_config.py` script to create a configuration file:
+
+```bash
+python3 scripts/setup_config.py
+
+# Initialize client
+client = Client(api_url, access_key_id, access_password)
+
+# Get user access info
+login_params = {'login_or_email': user_email, 'password': auth_token}
+response = client.make_call('users', 'user_access_info', params=login_params)
+
+# Extract UID from response
+import xml.etree.ElementTree as ET
+uid = ET.fromstring(response.content)[0].text
+
+# Get detailed user info
+params = {'uid': uid}
+user_info = client.make_call('users', 'user_info_via_id', params=params)
+```
+
+### 3. Notebook Operations
+
+Manage notebook access, backup, and metadata retrieval.
+
+**Key operations:**
+
+- **List notebooks:** Retrieve all notebooks accessible to a user
+- **Backup notebooks:** Download complete notebook data with optional attachment inclusion
+- **Get notebook IDs:** Retrieve institution-defined notebook identifiers for integration with grants/project management systems
+- **Get notebook members:** List all users with access to a specific notebook
+- **Get notebook settings:** Retrieve configuration and permissions for notebooks
+
+**Notebook backup example:**
+
+Use the `scripts/notebook_operations.py` script:
+
+```bash
+# Backup with attachments (default, creates 7z archive)
+python3 scripts/notebook_operations.py backup --uid USER_ID --nbid NOTEBOOK_ID
+
+### 4. Entry and Attachment Management
+
+Create, modify, and manage notebook entries and file attachments.
+
+**Entry operations:**
+- Create new entries in notebooks
+- Add comments to existing entries
+- Create entry parts/components
+- Upload file attachments to entries
+
+**Attachment workflow:**
+
+Use the `scripts/entry_operations.py` script:
+
+```bash
+# Upload attachment to an entry
+python3 scripts/entry_operations.py upload --uid USER_ID --nbid NOTEBOOK_ID --entry-id ENTRY_ID --file /path/to/file.pdf
+
+# Create a new entry with text content
+python3 scripts/entry_operations.py create --uid USER_ID --nbid NOTEBOOK_ID --title "Experiment Results" --content "Results from today's experiment..."
+
+

package/skills/lamindb/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: lamindb
+description: This skill should be used when working with LaminDB, an open-source data framework for biology that makes data queryable, traceable, reproducible, and FAIR. Use when managing biological datasets (scRNA-seq, spatial, flow cytometry, etc.), tracking computational workflows, curating and validating data with biological ontologies, building data lakehouses, or ensuring data lineage and reproducibility in biological research. Covers data management, annotation, ontologies (genes, cell types, diseases, tissues), schema validation, integrations with workflow managers (Nextflow, Snakemake) and MLOps platforms (W&B, MLflow), and deployment strategies.
+---
+
+# LaminDB
+
+## Overview
+
+LaminDB is an open-source data framework for biology designed to make data queryable, traceable, reproducible, and FAIR (Findable, Accessible, Interoperable, Reusable). It provides a unified platform that combines lakehouse architecture, lineage tracking, feature stores, biological ontologies, LIMS (Laboratory Information Management System), and ELN (Electronic Lab Notebook) capabilities through a single Python API.
+
+**Core Value Proposition:**
+- **Queryability**: Search and filter datasets by metadata, features, and ontology terms
+- **Traceability**: Automatic lineage tracking from raw data through analysis to results
+- **Reproducibility**: Version control for data, code, and environment
+- **FAIR Compliance**: Standardized annotations using biological ontologies
+
+## When to Use This Skill
+
+Use this skill when:
+
+- **Managing biological datasets**: scRNA-seq, bulk RNA-seq, spatial transcriptomics, flow cytometry, multi-modal data, EHR data
+- **Tracking computational workflows**: Notebooks, scripts, pipeline execution (Nextflow, Snakemake, Redun)
+- **Curating and validating data**: Schema validation, standardization, ontology-based annotation
+- **Working with biological ontologies**: Genes, proteins, cell types, tissues, diseases, pathways (via Bionty)
+- **Building data lakehouses**: Unified query interface across multiple datasets
+- **Ensuring reproducibility**: Automatic versioning, lineage tracking, environment capture
+- **Integrating ML pipelines**: Connecting with Weights & Biases, MLflow, HuggingFace, scVI-tools
+- **Deploying data infrastructure**: Setting up local or cloud-based data management systems
+- **Collaborating on datasets**: Sharing curated, annotated data with standardized metadata
+
+## Core Capabilities
+
+LaminDB provides six interconnected capability areas, each documented in detail in the references folder.
+
+### 1. Core Concepts and Data Lineage
+
+**Core entities:**
+- **Artifacts**: Versioned datasets (DataFrame, AnnData, Parquet, Zarr, etc.)
+- **Records**: Experimental entities (samples, perturbations, instruments)
+- **Runs & Transforms**: Computational lineage tracking (what code produced what data)
+- **Features**: Typed metadata fields for annotation and querying
+
+**Key workflows:**
+- Create and version artifacts from files or Python objects
+- Track notebook/script execution with `ln.track()` and `ln.finish()`
+- Annotate artifacts with typed features
+- Visualize data lineage graphs with `artifact.view_lineage()`
+- Query by provenance (find all outputs from specific code/inputs)
+
+**Reference:** `(see docs)` - Read this for detailed information on artifacts, records, runs, transforms, features, versioning, and lineage tracking.
+
+### 2. Data Management and Querying
+
+**Query capabilities:**
+- Registry exploration and lookup with auto-complete
+- Single record retrieval with `get()`, `one()`, `one_or_none()`
+- Filtering with comparison operators (`__gt`, `__lte`, `__contains`, `__startswith`)
+- Feature-based queries (query by annotated metadata)
+- Cross-registry traversal with double-underscore syntax
+- Full-text search across registries
+- Advanced logical queries with Q objects (AND, OR, NOT)
+- Streaming large datasets without loading into memory
+
+**Key workflows:**
+- Browse artifacts with filters and ordering
+- Query by features, creation date, creator, size, etc.
+
+### 3. Annotation and Validation
+
+**Curation process:**
+1. **Validation**: Confirm datasets match desired schemas
+2. **Standardization**: Fix typos, map synonyms to canonical terms
+3. **Annotation**: Link datasets to metadata entities for queryability
+
+**Schema types:**
+- **Flexible schemas**: Validate only known columns, allow additional metadata
+- **Minimal required schemas**: Specify essential columns, permit extras
+- **Strict schemas**: Complete control over structure and values
+
+**Supported data types:**
+- DataFrames (Parquet, CSV)
+- AnnData (single-cell genomics)
+
+### 4. Biological Ontologies
+
+**Available ontologies (via Bionty):**
+- Genes (Ensembl), Proteins (UniProt)
+- Cell types (CL), Cell lines (CLO)
+- Tissues (Uberon), Diseases (Mondo, DOID)
+- Phenotypes (HPO), Pathways (GO)
+- Experimental factors (EFO), Developmental stages
+- Organisms (NCBItaxon), Drugs (DrugBank)
+
+**Key workflows:**
+- Import public ontologies with `bt.CellType.import_source()`
+- Search ontologies with keyword or exact matching
+- Standardize terms using synonym mapping
+- Explore hierarchical relationships (parents, children, ancestors)
+
+### 5. Integrations
+
+**Workflow managers:**
+- Nextflow: Track pipeline processes and outputs
+- Snakemake: Integrate into Snakemake rules
+- Redun: Combine with Redun task tracking
+
+**MLOps platforms:**
+- Weights & Biases: Link experiments with data artifacts
+- MLflow: Track models and experiments
+- HuggingFace: Track model fine-tuning
+- scVI-tools: Single-cell analysis workflows
+
+**Storage systems:**
+- Local filesystem, AWS S3, Google Cloud Storage
+
+### 6. Setup and Deployment
+
+

package/skills/landsat/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: landsat
+description: Geospatial and remote sensing analysis with satellite imagery. Use when working with Landsat, Sentinel, raster data, land cover classification, NDVI calculation, or spatial data processing. Trigger on imports of rasterio, geopandas, xarray-spatial, or mentions of satellite, remote sensing, geospatial, raster, land cover.
+---
+# landsat
+
+Use this skill for satellite imagery and geospatial analysis.
+
+## Core patterns
+
+- **Load raster**: `rasterio.open('image.tif')` → `band = src.read(1)`.
+- **CRS transform**: `rasterio.warp.reproject()` for coordinate system conversion.
+- **NDVI**: `(nir - red) / (nir + red)` where Landsat 8: B5=NIR, B4=Red.
+- **Vector overlay**: `geopandas.sjoin(points, polygons)` for spatial joins.
+- **Zonal stats**: `rasterstats.zonal_stats(polygons, raster, stats=['mean', 'std'])`.
+
+## Rules
+
+- Always check CRS before spatial operations — mismatched CRS causes silent errors.
+- Use `with rasterio.open() as src:` for file handle safety.
+- Mask clouds using QA band — don't assume clear pixels.
+
+## Anti-patterns
+
+- Don't load entire raster into memory for large scenes — use windowed reading.
+- Don't reproject vector data repeatedly — reproject once, cache result.
+- Don't compute NDVI with integer division — cast to float first.
+
+

package/skills/latchbio-integration/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: latchbio-integration
+description: Latch platform for bioinformatics workflows. Build pipelines with Latch SDK, @workflow/@task decorators, deploy serverless workflows, LatchFile/LatchDir, Nextflow/Snakemake integration.
+---
+
+# LatchBio Integration
+
+## Overview
+
+Latch is a Python framework for building and deploying bioinformatics workflows as serverless pipelines. Built on Flyte, create workflows with @workflow/@task decorators, manage cloud data with LatchFile/LatchDir, configure resources, and integrate Nextflow/Snakemake pipelines.
+
+## Core Capabilities
+
+The Latch platform provides four main areas of functionality:
+
+### 1. Workflow Creation and Deployment
+- Define serverless workflows using Python decorators
+- Support for native Python, Nextflow, and Snakemake pipelines
+- Automatic containerization with Docker
+- Auto-generated no-code user interfaces
+- Version control and reproducibility
+
+### 2. Data Management
+- Cloud storage abstractions (LatchFile, LatchDir)
+- Structured data organization with Registry (Projects → Tables → Records)
+- Type-safe data operations with links and enums
+- Automatic file transfer between local and cloud
+- Glob pattern matching for file selection
+
+### 3. Resource Configuration
+- Pre-configured task decorators (@small_task, @large_task, @small_gpu_task, @large_gpu_task)
+- Custom resource specifications (CPU, memory, GPU, storage)
+- GPU support (K80, V100, A100)
+- Timeout and storage configuration
+- Cost optimization strategies
+
+### 4. Verified Workflows
+- Production-ready pre-built pipelines
+- Bulk RNA-seq, DESeq2, pathway analysis
+- AlphaFold and ColabFold for protein structure prediction
+- Single-cell tools (ArchR, scVelo, emptyDropsR)
+- CRISPR analysis, phylogenetics, and more
+
+## Quick Start
+
+# Login to Latch
+latch login
+
+# Initialize a new workflow
+latch init my-workflow
+
+# Register workflow to platform
+latch register my-workflow
+```
+
+**Prerequisites:**
+- Docker installed and running
+- Latch account credentials
+- Python 3.8+
+
+### Basic Workflow Example
+
+```python
+from latch import workflow, small_task
+from latch.types import LatchFile
+
+@small_task
+def process_file(input_file: LatchFile) -> LatchFile:
+    """Process a single file"""
+    # Processing logic
+    return output_file
+
+@workflow
+def my_workflow(input_file: LatchFile) -> LatchFile:
+    """
+
+## When to Use This Skill
+
+This skill should be used when encountering any of the following scenarios:
+
+**Workflow Development:**
+- "Create a Latch workflow for RNA-seq analysis"
+- "Deploy my pipeline to Latch"
+- "Convert my Nextflow pipeline to Latch"
+- "Add GPU support to my workflow"
+- Working with `@workflow`, `@task` decorators
+
+**Data Management:**
+- "Organize my sequencing data in Latch Registry"
+- "How do I use LatchFile and LatchDir?"
+- "Set up sample tracking in Latch"
+
+## Detailed Documentation
+
+This skill includes comprehensive reference documentation organized by capability:
+
+### (see docs)
+**Read this for:**
+- Creating and registering workflows
+- Task definition and decorators
+- Supporting Python, Nextflow, Snakemake
+- Launch plans and conditional sections
+- Workflow execution (CLI and programmatic)
+- Multi-step and parallel pipelines
+- Troubleshooting registration issues
+
+**Key topics:**
+- `latch init` and `latch register` commands
+- `@workflow` and `@task` decorators
+- LatchFile and LatchDir basics
+- Type annotations and docstrings
+- Launch plans with preset parameters
+- Conditional UI sections
+
+### (see docs)
+**Read this for:**
+
+

package/skills/latex-posters/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: latex-posters
+description: "Create professional research posters in LaTeX using beamerposter, tikzposter, or baposter. Support for conference presentations, academic posters, and scientific communication. Includes layout design, color schemes, multi-column formats, figure integration, and poster-specific best practices for visual communication."
+---
+
+# LaTeX Research Posters
+
+## Overview
+
+Research posters are a critical medium for scientific communication at conferences, symposia, and academic events. This skill provides comprehensive guidance for creating professional, visually appealing research posters using LaTeX packages. Generate publication-quality posters with proper layout, typography, color schemes, and visual hierarchy.
+
+## When to Use This Skill
+
+This skill should be used when:
+- Creating research posters for conferences, symposia, or poster sessions
+- Designing academic posters for university events or thesis defenses
+- Preparing visual summaries of research for public engagement
+- Converting scientific papers into poster format
+- Creating template posters for research groups or departments
+- Designing posters that comply with specific conference size requirements (A0, A1, 36×48", etc.)
+- Building posters with complex multi-column layouts
+- Integrating figures, tables, equations, and citations in poster format
+
+## AI-Powered Visual Element Generation
+
+**STANDARD WORKFLOW: Generate ALL major visual elements using AI before creating the LaTeX poster.**
+
+This is the recommended approach for creating visually compelling posters:
+1. Plan all visual elements needed (title, intro, methods, results, conclusions)
+2. Generate each element using scientific-schematics or Nano Banana Pro
+3. Assemble generated images in the LaTeX template
+4. Add text content around the visuals
+
+**Target: 60-70% of poster area should be AI-generated visuals, 30-40% text.**
+
+---
+
+### CRITICAL: Preventing Content Overflow
+
+**⚠️ POSTERS MUST NOT HAVE TEXT OR CONTENT CUT OFF AT EDGES.**
+
+**Common Overflow Problems:**
+1. **Title/footer text extending beyond page boundaries**
+2. **Too many sections crammed into available space**
+3. **Figures placed too close to edges**
+4. **Text blocks exceeding column widths**
+
+**Prevention Rules:**
+
+**1. Limit Content Sections (MAXIMUM 5-6 sections for A0):**
+```
+✅ GOOD - 5 sections with room to breathe:
+
+# Compile and check PDF at 100% zoom
+pdflatex poster.tex
+
+# Look for:
+# - Text cut off at any edge
+# - Content touching page boundaries  
+# - Overfull hbox warnings in .log file
+grep -i "overfull" poster.log
+```
+
+**5. Word Count Limits:**
+- **A0 poster**: 300-800 words MAXIMUM
+- **Per section**: 50-100 words maximum
+- **If you have more content**: Cut it or make a handout
+
+---
+
+### CRITICAL: Poster-Size Font Requirements
+
+**⚠️ ALL text within AI-generated visualizations MUST be poster-readable.**
+
+When generating graphics for posters, you MUST include font size specifications in EVERY prompt. Poster graphics are viewed from 4-6 feet away, so text must be LARGE.
+
+**⚠️ COMMON PROBLEM: Content Overflow and Density**
+
+The #1 issue with AI-generated poster graphics is **TOO MUCH CONTENT**. This causes:
+- Text overflow beyond boundaries
+- Unreadable small fonts
+- Cluttered, overwhelming visuals
+- Poor white space usage
+
+**SOLUTION: Generate SIMPLE graphics with MINIMAL content.**
+
+# ❌ BAD - This creates tiny unreadable text like the drug discovery poster
+python scripts/generate_schematic.py "Drug discovery workflow showing: Stage 1 Target Identification, Stage 2 Molecular Synthesis, Stage 3 Virtual Screening, Stage 4 AI Lead Optimization, Stage 5 Clinical Trial Design, Stage 6 FDA Approval. Include success metrics, timelines, and validation steps for each stage." -o figures/workflow.png
+# Result: 7+ stages with tiny text, unreadable from 6 feet - POSTER FAILURE
+```
+
+**Example - CORRECT (simplified to 3 key stages):**
+```bash
+# ✅ GOOD - Same content, split into ONE simple high-level graphic
+python scripts/generate_schematic.py "POSTER FORMAT for A0. ULTRA-SIMPLE 3-box workflow: 'DISCOVER' → 'VALIDATE' → 'APPROVE'. Each word in GIANT bold (120pt+). Thick arrows (10px). 60% white space. NO substeps, NO details. 3 words total. Readable from 10 feet." -o figures/workflow_overview.png
+# Result: Clean, impactful, readable - can add detail graphics separately if needed
+```
+
+**Example - WRONG (complex case studies with multiple sections):**
+```bash
+# ❌ BAD - Creates cramped unreadable sections
+python scripts/generate_schematic.py "Case studies: Insilico Medicine (drug candidate, discovery time, clinical trials), Recursion Pharma (platform, methodology, results), Exscientia (drug candidates, FDA status, timeline). Include company logos, metrics, and outcomes." -o figures/cases.png
+# Result: 3 case studies with 4+ elements each = 12+ total elements, tiny text
+```
+
+**Example - CORRECT (one case study, one key metric):**
+```bash
+# ✅ GOOD - Show ONE case with ONE key number
+python scripts/generate_schematic.py "POSTER FORMAT for A0. ONE case study card: Company logo (large), '18 MONTHS' in GIANT text (150pt), 'to discovery' below (60pt). 3 elements total: logo + number + caption. 50% white space. Readable from 10 feet." -o figures/case_single.png
+# Result: Clear, readable, impactful. Make 3 separate graphics if you need 3 cases.
+
+