Agent skill

Scientific Schematics

by spacering-net in spacering-net/codeg

Create publication-quality scientific diagrams using Nano Banana 2 AI with smart iterative refinement.

MITAuto-check: notesDevelopment

Install Scientific Schematics

skills CLI
$ npx skills add spacering-net/codeg --skill scientific-schematics -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install spacering-net/codeg scientific-schematics --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/spacering-net/codeg.git skills-src && mkdir -p .claude/skills && cp -r skills-src/src-tauri/science/skills/scientific-schematics .claude/skills/scientific-schematics && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
scientific-schematics
GitHub stars
3.9k
Used in
11 other repos
Token cost
~5.9k tokens
SKILL.md length
1,748 words
Files
7 (incl. scripts, references)
Skills in repo
10
Repo updated
First seen
Licence
MIT

At a glance

Create publication-quality scientific diagrams using Nano Banana 2 AI with smart iterative refinement.

  • Works in 5 steps: Generation 1: Nano Banana 2 creates… → Review 1: Gemini 3.1 Pro Preview… → Decision: If quality >= threshold → DONE… → …
  • Tasks that involve Data visualization
  • SKILL.md covers Overview, Quick Start: Generate Any…, When to Use This Skill and How to Use This Skill, plus 6 more sections
  • Runs Python and Shell scripts from its folder; calls python; reaches openrouter.ai; needs OPENROUTER_API_KEY

What it does

Scientific Schematics is an agent skill from spacering-net/codeg. Create publication-quality scientific diagrams using Nano Banana 2 AI with smart iterative refinement. Uses Gemini 3.1 Pro Preview for quality review. Only regenerates if quality is below threshold for your document type. Specialized in neural network architectures, system diagrams, flowcharts, biological pathways, and complex scientific visualizations.

Its SKILL.md is about 5.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 8 other files, including scripts and reference files (for example `references/QUICK_REFERENCE.md`, `references/README.md` and `references/best_practices.md`).

It sits in Development, covering Data visualization, Diagrams and Image generation. It works with Google Gemini. The repository describes itself as: Collaborative multi-agent AI coding workspace: aggregate sessions from Claude Code, Codex, OpenCode, Pi, Grok Build, etc. Desktop app, self-hosted server, or Docker. The licence is MIT.

When your agent uses it

  • Tasks that involve Data visualization
  • Tasks that involve Diagrams
  • Tasks that involve Image generation

Example prompts

  • “/scientific-schematics”

Requirements

  • Python 3
  • A Bash shell
  • A credential in OPENROUTER_API_KEY
  • Pre-approved tools (allowed-tools): Read, Write, Edit, Bash

Workflow steps

5 steps, taken from the first numbered list in SKILL.md.

  1. Generation 1: Nano Banana 2 creates initial image following scientific diagram best practices
  2. Review 1: Gemini 3.1 Pro Preview evaluates quality against document-type threshold
  3. Decision: If quality >= threshold → DONE (no more iterations needed!)
  4. If below threshold: Improved prompt based on critique, regenerate
  5. Repeat: Until quality meets threshold OR max iterations reached

What it can do on your machine

Read from SKILL.md and the folder at commit 05905cc. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • Edit
    • Bash

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 3 files in scripts/ (Python and Shell), which the agent can run.

    Shell commands in SKILL.md call:

    • python

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • openrouter.ai

    Also links to:

    • schemdraw.readthedocs.io
    • networkx.org
    • matplotlib.org
    • nature.com
    • science.org
    • consort-statement.org

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • OPENROUTER_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Scientific Schematics loads about 5.9k tokens when it runs, and up to ~13k if it reads all its reference files. Until then it costs about 94 tokens; SKILL.md has 1,748 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~94
When it runs · the whole SKILL.md, loaded when a task matches
~5.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~13k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Read, Write, Edit, Bash

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from spacering-net/codeg at commit 05905cc, republished under its MIT licence (© spacering-net). 1,748 words, ~5,949 tokens.

Download SKILL.mdSave it as .claude/skills/scientific-schematics/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
scientific-schematics
description
Create publication-quality scientific diagrams using Nano Banana 2 AI with smart iterative refinement. Uses Gemini 3.1 Pro Preview for quality review. Only regenerates if quality is below threshold for your document type. Specialized in neural network architectures, system diagrams, flowcharts, biological pathways, and complex scientific visualizations.
allowed-tools
Read, Write, Edit, Bash
license
MIT license
metadata.version
1.1
metadata.skill-author
K-Dense Inc.

Scientific Schematics and Diagrams

Overview

Scientific schematics and diagrams transform complex concepts into clear visual representations for publication. This skill uses Nano Banana 2 AI for diagram generation with Gemini 3.1 Pro Preview quality review.

How it works:

  • Describe your diagram in natural language
  • Nano Banana 2 generates publication-quality images automatically
  • Gemini 3.1 Pro Preview reviews quality against document-type thresholds
  • Smart iteration: Only regenerates if quality is below threshold
  • Publication-ready output in minutes
  • No coding, templates, or manual drawing required

Quality Thresholds by Document Type:

Document TypeThresholdDescription
journal8.5/10Nature, Science, peer-reviewed journals
conference8.0/10Conference papers
thesis8.0/10Dissertations, theses
grant8.0/10Grant proposals
preprint7.5/10arXiv, bioRxiv, etc.
report7.5/10Technical reports
poster7.0/10Academic posters
presentation6.5/10Slides, talks
default7.5/10General purpose

Simply describe what you want, and Nano Banana 2 creates it. All diagrams are stored in the figures/ subfolder and referenced in papers/posters.

Quick Start: Generate Any Diagram

Create any scientific diagram by simply describing it. Nano Banana 2 handles everything automatically with smart iteration:

bash
# Generate for journal paper (highest quality threshold: 8.5/10)
python scripts/generate_schematic.py "CONSORT participant flow diagram with 500 screened, 150 excluded, 350 randomized" -o figures/consort.png --doc-type journal

# Generate for presentation (lower threshold: 6.5/10 - faster)
python scripts/generate_schematic.py "Transformer encoder-decoder architecture showing multi-head attention" -o figures/transformer.png --doc-type presentation

# Generate for poster (moderate threshold: 7.0/10)
python scripts/generate_schematic.py "MAPK signaling pathway from EGFR to gene transcription" -o figures/mapk_pathway.png --doc-type poster

# Custom max iterations (max 2)
python scripts/generate_schematic.py "Complex circuit diagram with op-amp, resistors, and capacitors" -o figures/circuit.png --iterations 2 --doc-type journal

What happens behind the scenes:

  1. Generation 1: Nano Banana 2 creates initial image following scientific diagram best practices
  2. Review 1: Gemini 3.1 Pro Preview evaluates quality against document-type threshold
  3. Decision: If quality >= threshold → DONE (no more iterations needed!)
  4. If below threshold: Improved prompt based on critique, regenerate
  5. Repeat: Until quality meets threshold OR max iterations reached

Smart Iteration Benefits:

  • ✅ Saves API calls if first generation is good enough
  • ✅ Higher quality standards for journal papers
  • ✅ Faster turnaround for presentations/posters
  • ✅ Appropriate quality for each use case

Output: Versioned images plus a detailed review log with quality scores, critiques, and early-stop information.

Configuration

Set your OpenRouter API key:

bash
export OPENROUTER_API_KEY='your_api_key_here'

Get an API key at: https://openrouter.ai/keys

AI Generation Best Practices

Effective Prompts for Scientific Diagrams:

✓ Good prompts (specific, detailed):

  • "CONSORT flowchart showing participant flow from screening (n=500) through randomization to final analysis"
  • "Transformer neural network architecture with encoder stack on left, decoder stack on right, showing multi-head attention and cross-attention connections"
  • "Biological signaling cascade: EGFR receptor → RAS → RAF → MEK → ERK → nucleus, with phosphorylation steps labeled"
  • "Block diagram of IoT system: sensors → microcontroller → WiFi module → cloud server → mobile app"

✗ Avoid vague prompts:

  • "Make a flowchart" (too generic)
  • "Neural network" (which type? what components?)
  • "Pathway diagram" (which pathway? what molecules?)

Key elements to include:

  • Type: Flowchart, architecture diagram, pathway, circuit, etc.
  • Components: Specific elements to include
  • Flow/Direction: How elements connect (left-to-right, top-to-bottom)
  • Labels: Key annotations or text to include
  • Style: Any specific visual requirements

Scientific Quality Guidelines (automatically applied):

  • Clean white/light background
  • High contrast for readability
  • Clear, readable labels (minimum 10pt)
  • Professional typography (sans-serif fonts)
  • Colorblind-friendly colors (Okabe-Ito palette)
  • Proper spacing to prevent crowding
  • Scale bars, legends, axes where appropriate

When to Use This Skill

This skill should be used when:

  • Creating neural network architecture diagrams (Transformers, CNNs, RNNs, etc.)
  • Illustrating system architectures and data flow diagrams
  • Drawing methodology flowcharts for study design (CONSORT, PRISMA)
  • Visualizing algorithm workflows and processing pipelines
  • Creating circuit diagrams and electrical schematics
  • Depicting biological pathways and molecular interactions
  • Generating network topologies and hierarchical structures
  • Illustrating conceptual frameworks and theoretical models
  • Designing block diagrams for technical papers

How to Use This Skill

Simply describe your diagram in natural language. Nano Banana 2 generates it automatically:

bash
python scripts/generate_schematic.py "your diagram description" -o output.png

That's it! The AI handles:

  • ✓ Layout and composition
  • ✓ Labels and annotations
  • ✓ Colors and styling
  • ✓ Quality review and refinement
  • ✓ Publication-ready output

Works for all diagram types:

  • Flowcharts (CONSORT, PRISMA, etc.)
  • Neural network architectures
  • Biological pathways
  • Circuit diagrams
  • System architectures
  • Block diagrams
  • Any scientific visualization

No coding, no templates, no manual drawing required.


AI Generation Mode (Nano Banana 2 + Gemini 3.1 Pro Preview Review)

Smart Iterative Refinement Workflow

The AI generation system uses smart iteration - it only regenerates if quality is below the threshold for your document type:

How Smart Iteration Works
┌─────────────────────────────────────────────────────┐
│  1. Generate image with Nano Banana 2             │
│                    ↓                                │
│  2. Review quality with Gemini 3.1 Pro Preview                │
│                    ↓                                │
│  3. Score >= threshold?                             │
│       YES → DONE! (early stop)                      │
│       NO  → Improve prompt, go to step 1            │
│                    ↓                                │
│  4. Repeat until quality met OR max iterations      │
└─────────────────────────────────────────────────────┘
Iteration 1: Initial Generation

Prompt Construction:

Scientific diagram guidelines + User request

Output: diagram_v1.png

Quality Review by Gemini 3.1 Pro Preview

Gemini 3.1 Pro Preview evaluates the diagram on:

  1. Scientific Accuracy (0-2 points) - Correct concepts, notation, relationships
  2. Clarity and Readability (0-2 points) - Easy to understand, clear hierarchy
  3. Label Quality (0-2 points) - Complete, readable, consistent labels
  4. Layout and Composition (0-2 points) - Logical flow, balanced, no overlaps
  5. Professional Appearance (0-2 points) - Publication-ready quality

Example Review Output:

SCORE: 8.0

STRENGTHS:
- Clear flow from top to bottom
- All phases properly labeled
- Professional typography

ISSUES:
- Participant counts slightly small
- Minor overlap on exclusion box

VERDICT: ACCEPTABLE (for poster, threshold 7.0)
Decision Point: Continue or Stop?
If Score...Action
>= thresholdSTOP - Quality is good enough for this document type
< thresholdContinue to next iteration with improved prompt

Example:

  • For a poster (threshold 7.0): Score of 7.5 → DONE after 1 iteration!
  • For a journal (threshold 8.5): Score of 7.5 → Continue improving
Subsequent Iterations (Only If Needed)

If quality is below threshold, the system:

  1. Extracts specific issues from Gemini 3.1 Pro Preview's review
  2. Enhances the prompt with improvement instructions
  3. Regenerates with Nano Banana 2
  4. Reviews again with Gemini 3.1 Pro Preview
  5. Repeats until threshold met or max iterations reached
Review Log

All iterations are saved with a JSON review log that includes early-stop information:

json
{
  "user_prompt": "CONSORT participant flow diagram...",
  "doc_type": "poster",
  "quality_threshold": 7.0,
  "iterations": [
    {
      "iteration": 1,
      "image_path": "figures/consort_v1.png",
      "score": 7.5,
      "needs_improvement": false,
      "critique": "SCORE: 7.5\nSTRENGTHS:..."
    }
  ],
  "final_score": 7.5,
  "early_stop": true,
  "early_stop_reason": "Quality score 7.5 meets threshold 7.0 for poster"
}

Note: With smart iteration, you may see only 1 iteration instead of the full 2 if quality is achieved early!

Advanced AI Generation Usage

Python API
python
from scripts.generate_schematic_ai import ScientificSchematicGenerator

# Initialize generator
generator = ScientificSchematicGenerator(
    api_key="your_openrouter_key",
    verbose=True
)

# Generate with iterative refinement (max 2 iterations)
results = generator.generate_iterative(
    user_prompt="Transformer architecture diagram",
    output_path="figures/transformer.png",
    iterations=2
)

# Access results
print(f"Final score: {results['final_score']}/10")
print(f"Final image: {results['final_image']}")

# Review individual iterations
for iteration in results['iterations']:
    print(f"Iteration {iteration['iteration']}: {iteration['score']}/10")
    print(f"Critique: {iteration['critique']}")
Command-Line Options
bash
# Basic usage (default threshold 7.5/10)
python scripts/generate_schematic.py "diagram description" -o output.png

# Specify document type for appropriate quality threshold
python scripts/generate_schematic.py "diagram" -o out.png --doc-type journal      # 8.5/10
python scripts/generate_schematic.py "diagram" -o out.png --doc-type conference   # 8.0/10
python scripts/generate_schematic.py "diagram" -o out.png --doc-type poster       # 7.0/10
python scripts/generate_schematic.py "diagram" -o out.png --doc-type presentation # 6.5/10

# Custom max iterations (1-2)
python scripts/generate_schematic.py "complex diagram" -o diagram.png --iterations 2

# Verbose output (see all API calls and reviews)
python scripts/generate_schematic.py "flowchart" -o flow.png -v

# Provide API key via flag
python scripts/generate_schematic.py "diagram" -o out.png --api-key "sk-or-v1-..."

# Combine options
python scripts/generate_schematic.py "neural network" -o nn.png --doc-type journal --iterations 2 -v
Prompt Engineering Tips

1. Be Specific About Layout:

✓ "Flowchart with vertical flow, top to bottom"
✓ "Architecture diagram with encoder on left, decoder on right"
✓ "Circular pathway diagram with clockwise flow"

2. Include Quantitative Details:

✓ "Neural network with input layer (784 nodes), hidden layer (128 nodes), output (10 nodes)"
✓ "Flowchart showing n=500 screened, n=150 excluded, n=350 randomized"
✓ "Circuit with 1kΩ resistor, 10µF capacitor, 5V source"

3. Specify Visual Style:

✓ "Minimalist block diagram with clean lines"
✓ "Detailed biological pathway with protein structures"
✓ "Technical schematic with engineering notation"

4. Request Specific Labels:

✓ "Label all arrows with activation/inhibition"
✓ "Include layer dimensions in each box"
✓ "Show time progression with timestamps"

5. Mention Color Requirements:

✓ "Use colorblind-friendly colors"
✓ "Grayscale-compatible design"
✓ "Color-code by function: blue for input, green for processing, red for output"

AI Generation Examples

Example 1: CONSORT Flowchart
bash
python scripts/generate_schematic.py \
  "CONSORT participant flow diagram for randomized controlled trial. \
   Start with 'Assessed for eligibility (n=500)' at top. \
   Show 'Excluded (n=150)' with reasons: age<18 (n=80), declined (n=50), other (n=20). \
   Then 'Randomized (n=350)' splits into two arms: \
   'Treatment group (n=175)' and 'Control group (n=175)'. \
   Each arm shows 'Lost to follow-up' (n=15 and n=10). \
   End with 'Analyzed' (n=160 and n=165). \
   Use blue boxes for process steps, orange for exclusion, green for final analysis." \
  -o figures/consort.png
Example 2: Neural Network Architecture
bash
python scripts/generate_schematic.py \
  "Transformer encoder-decoder architecture diagram. \
   Left side: Encoder stack with input embedding, positional encoding, \
   multi-head self-attention, add & norm, feed-forward, add & norm. \
   Right side: Decoder stack with output embedding, positional encoding, \
   masked self-attention, add & norm, cross-attention (receiving from encoder), \
   add & norm, feed-forward, add & norm, linear & softmax. \
   Show cross-attention connection from encoder to decoder with dashed line. \
   Use light blue for encoder, light red for decoder. \
   Label all components clearly." \
  -o figures/transformer.png --iterations 2
Example 3: Biological Pathway
bash
python scripts/generate_schematic.py \
  "MAPK signaling pathway diagram. \
   Start with EGFR receptor at cell membrane (top). \
   Arrow down to RAS (with GTP label). \
   Arrow to RAF kinase. \
   Arrow to MEK kinase. \
   Arrow to ERK kinase. \
   Final arrow to nucleus showing gene transcription. \
   Label each arrow with 'phosphorylation' or 'activation'. \
   Use rounded rectangles for proteins, different colors for each. \
   Include membrane boundary line at top." \
  -o figures/mapk_pathway.png
Example 4: System Architecture
bash
python scripts/generate_schematic.py \
  "IoT system architecture block diagram. \
   Bottom layer: Sensors (temperature, humidity, motion) in green boxes. \
   Middle layer: Microcontroller (ESP32) in blue box. \
   Connections to WiFi module (orange box) and Display (purple box). \
   Top layer: Cloud server (gray box) connected to mobile app (light blue box). \
   Show data flow arrows between all components. \
   Label connections with protocols: I2C, UART, WiFi, HTTPS." \
  -o figures/iot_architecture.png

Command-Line Usage

The main entry point for generating scientific schematics:

bash
# Basic usage
python scripts/generate_schematic.py "diagram description" -o output.png

# Custom iterations (max 2)
python scripts/generate_schematic.py "complex diagram" -o diagram.png --iterations 2

# Verbose mode
python scripts/generate_schematic.py "diagram" -o out.png -v

Note: The Nano Banana 2 AI generation system includes automatic quality review in its iterative refinement process. Each iteration is evaluated for scientific accuracy, clarity, and accessibility.

Best Practices Summary

Design Principles
  1. Clarity over complexity - Simplify, remove unnecessary elements
  2. Consistent styling - Use templates and style files
  3. Colorblind accessibility - Use Okabe-Ito palette, redundant encoding
  4. Appropriate typography - Sans-serif fonts, minimum 7-8 pt
  5. Vector format - Always use PDF/SVG for publication
Technical Requirements
  1. Resolution - Vector preferred, or 300+ DPI for raster
  2. File format - PDF for LaTeX, SVG for web, PNG as fallback
  3. Color space - RGB for digital, CMYK for print (convert if needed)
  4. Line weights - Minimum 0.5 pt, typical 1-2 pt
  5. Text size - 7-8 pt minimum at final size
Show full SKILL.md (722 more words)Show less
Integration Guidelines
  1. Include in LaTeX - Use \includegraphics{} for generated images
  2. Caption thoroughly - Describe all elements and abbreviations
  3. Reference in text - Explain diagram in narrative flow
  4. Maintain consistency - Same style across all figures in paper
  5. Version control - Keep prompts and generated images in repository

Troubleshooting Common Issues

AI Generation Issues

Problem: Overlapping text or elements

  • Solution: AI generation automatically handles spacing
  • Solution: Increase iterations: --iterations 2 for better refinement

Problem: Elements not connecting properly

  • Solution: Make your prompt more specific about connections and layout
  • Solution: Increase iterations for better refinement
Image Quality Issues

Problem: Export quality poor

  • Solution: AI generation produces high-quality images automatically
  • Solution: Increase iterations for better results: --iterations 2

Problem: Elements overlap after generation

  • Solution: AI generation automatically handles spacing
  • Solution: Increase iterations: --iterations 2 for better refinement
  • Solution: Make your prompt more specific about layout and spacing requirements
Quality Check Issues

Problem: False positive overlap detection

  • Solution: Adjust threshold: detect_overlaps(image_path, threshold=0.98)
  • Solution: Manually review flagged regions in visual report

Problem: Generated image quality is low

  • Solution: AI generation produces high-quality images by default
  • Solution: Increase iterations for better results: --iterations 2

Problem: Colorblind simulation shows poor contrast

  • Solution: Switch to Okabe-Ito palette explicitly in code
  • Solution: Add redundant encoding (shapes, patterns, line styles)
  • Solution: Increase color saturation and lightness differences

Problem: High-severity overlaps detected

  • Solution: Review overlap_report.json for exact positions
  • Solution: Increase spacing in those specific regions
  • Solution: Re-run with adjusted parameters and verify again

Problem: Visual report generation fails

  • Solution: Check Pillow and matplotlib installations
  • Solution: Ensure image file is readable: Image.open(path).verify()
  • Solution: Check sufficient disk space for report generation
Accessibility Problems

Problem: Colors indistinguishable in grayscale

  • Solution: Run accessibility checker: verify_accessibility(image_path)
  • Solution: Add patterns, shapes, or line styles for redundancy
  • Solution: Increase contrast between adjacent elements

Problem: Text too small when printed

  • Solution: Run resolution validator: validate_resolution(image_path)
  • Solution: Design at final size, use minimum 7-8 pt fonts
  • Solution: Check physical dimensions in resolution report

Problem: Accessibility checks consistently fail

  • Solution: Review accessibility_report.json for specific failures
  • Solution: Increase color contrast by at least 20%
  • Solution: Test with actual grayscale conversion before finalizing

Resources and References

Detailed References

Load these files for comprehensive information on specific topics:

  • references/best_practices.md - Publication standards and accessibility guidelines
External Resources

Python Libraries

Publication Standards

Integration with Other Skills

This skill works synergistically with:

  • Scientific Writing - Diagrams follow figure best practices
  • Scientific Visualization - Shares color palettes and styling
  • LaTeX Posters - Generate diagrams for poster presentations
  • Research Grants - Methodology diagrams for proposals
  • Peer Review - Evaluate diagram clarity and accessibility

Quick Reference Checklist

Before submitting diagrams, verify:

Visual Quality
  • High-quality image format (PNG from AI generation)
  • No overlapping elements (AI handles automatically)
  • Adequate spacing between all components (AI optimizes)
  • Clean, professional alignment
  • All arrows connect properly to intended targets
Accessibility
  • Colorblind-safe palette (Okabe-Ito) used
  • Works in grayscale (tested with accessibility checker)
  • Sufficient contrast between elements (verified)
  • Redundant encoding where appropriate (shapes + colors)
  • Colorblind simulation passes all checks
Typography and Readability
  • Text minimum 7-8 pt at final size
  • All elements labeled clearly and completely
  • Consistent font family and sizing
  • No text overlaps or cutoffs
  • Units included where applicable
Publication Standards
  • Consistent styling with other figures in manuscript
  • Comprehensive caption written with all abbreviations defined
  • Referenced appropriately in manuscript text
  • Meets journal-specific dimension requirements
  • Exported in required format for journal (PDF/EPS/TIFF)
Quality Verification (Required)
  • Ran run_quality_checks() and achieved PASS status
  • Reviewed overlap detection report (zero high-severity overlaps)
  • Passed accessibility verification (grayscale and colorblind)
  • Resolution validated at target DPI (300+ for print)
  • Visual quality report generated and reviewed
  • All quality reports saved with figure files
Documentation and Version Control
  • Source files (.tex, .py) saved for future revision
  • Quality reports archived in quality_reports/ directory
  • Configuration parameters documented (colors, spacing, sizes)
  • Git commit includes source, output, and quality reports
  • README or comments explain how to regenerate figure
Final Integration Check
  • Figure displays correctly in compiled manuscript
  • Cross-references work (\ref{} points to correct figure)
  • Figure number matches text citations
  • Caption appears on correct page relative to figure
  • No compilation warnings or errors related to figure

Environment Setup

bash
# Required
export OPENROUTER_API_KEY='your_api_key_here'

# Get key at: https://openrouter.ai/keys

Getting Started

Simplest possible usage:

bash
python scripts/generate_schematic.py "your diagram description" -o output.png

Use this skill to create clear, accessible, publication-quality diagrams that effectively communicate complex scientific concepts. The AI-powered workflow with iterative refinement ensures diagrams meet professional standards.

© spacering-net, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 6 other files (scripts, references) in src-tauri/science/skills/scientific-schematics of spacering-net/codeg.

  • SKILL.md
  • references/QUICK_REFERENCE.md
  • references/README.md
  • references/best_practices.md
  • scripts/example_usage.sh
  • scripts/generate_schematic.py
  • scripts/generate_schematic_ai.py

Open the folder on GitHubat commit 05905cc

Used in 11 other repositories

We found 14 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 11 other GitHub owners. This page covers the copy in spacering-net/codeg, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Scientific Schematics next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Scientific Schematics compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Scientific Schematics this skillspacering-net/codeg3.9k11 repos~5.9kAutomated safety check: NotesMIT
Scientific SchematicsK-Dense-AI/claude-scientific-writer2.4k1 repos~4.3kAutomated safety check: NotesMIT
Scientific SchematicsK-Dense-AI/scientific-agent-skills48k1 repos~5.1kAutomated safety check: NotesMIT
Paper Figure GenerateGRIND-Lab-Core/night_owl_research_agent106—~5.1kAutomated safety check: NotesNone
Engineering Figure Agentheyu-233/engineering-figure-agent307—~1.1kAutomated safety check: PassMIT
Generate ImageK-Dense-AI/claude-scientific-writer2.4k1 repos~3.8kAutomated safety check: NotesMIT

Similar skills

  • Scientific Schematics

    K-Dense-AI/claude-scientific-writer

    Create publication-quality scientific diagrams using Nano Banana 2 AI with smart iterative refinement.

    2.4k GitHub starsUsed in 1 repo~4.3k tokens
    Data & AnalyticsAuto-check: notes
  • Scientific Schematics

    K-Dense-AI/scientific-agent-skills

    Generates scientific diagram drafts using Nano Banana 2 AI with smart iterative refinement.

    48k GitHub starsUsed in 1 repo~5.1k tokens
    DevelopmentAuto-check: notes
  • Paper Figure Generate

    GRIND-Lab-Core/night_owl_research_agent

    Generates publication-quality figures and diagrams from output/PAPERPLAN.md for GIScience, GeoAI, and remote sensing journals (IJGIS, ISPRS JPRS, RSE, TGIS).

    106 GitHub stars~5.1k tokensUpdated 5 mo ago
    Media & CreativeAuto-check: notes
  • Engineering Figure Agent

    heyu-233/engineering-figure-agent

    A skill your agent uses when the user needs engineering or research-paper figures: system architecture diagrams, algorithm workflows, hardware schematics, benchmark charts, ablation plots, figure…

    307 GitHub stars~1.1k tokensUpdated 4 mo ago
    Research & ScienceAuto-check passed
  • Generate Image

    K-Dense-AI/claude-scientific-writer

    Generate or edit images with AI models through the OpenRouter Image API (Gemini, Seedream, Recraft, GPT-Image, Riverflow).

    2.4k GitHub starsUsed in 1 repo~3.8k tokens
    Media & CreativeAuto-check: notes
  • Figure

    Muuuun/luxas

    Hybrid figure pipeline (Nano Banana raster + rembg background removal + TikZ vector assembly).

    1.2k GitHub stars~1.2k tokensUpdated 1 mo ago
    Media & CreativeAuto-check passed

More from spacering-net/codeg

All 10 skills in this repo
  • Exploratory Data Analysis

    spacering-net/codeg

    Perform comprehensive exploratory data analysis on scientific data files across 200+ file formats.

    3.9k GitHub starsUsed in 14 repos~3.6k tokens
    Auto-check passed
  • Hypothesis Generation

    spacering-net/codeg

    Structured hypothesis formulation from observations. An agent skill from spacering-net/codeg.

    3.9k GitHub starsUsed in 14 repos~3.6k tokens
    Auto-check: notes
  • Peer Review

    spacering-net/codeg

    Structured manuscript/grant review with checklist-based evaluation.

    3.9k GitHub starsUsed in 17 repos~5.9k tokens
    Auto-check: notes
  • Statistical Analysis

    spacering-net/codeg

    Guided statistical analysis for research data - test selection, assumption checking, effect sizes, power analysis, Bayesian alternatives, and APA-formatted reporting.

    3.9k GitHub starsUsed in 3 repos~5k tokens
    Auto-check passed
  • Scholar Evaluation

    spacering-net/codeg

    Systematically evaluate scholarly work using the ScholarEval framework, providing structured assessment across research quality dimensions including problem formulation, methodology, analysis, and…

    3.9k GitHub starsUsed in 11 repos~3.2k tokens
    Auto-check passed
  • Statistical Power

    spacering-net/codeg

    Sample-size and statistical power calculations for planning studies.

    3.9k GitHub starsUsed in 1 repo~3.6k tokens
    Auto-check: notes

Works with

Questions about Scientific Schematics

What does Scientific Schematics do?

Create publication-quality scientific diagrams using Nano Banana 2 AI with smart iterative refinement. Scientific Schematics is an agent skill from spacering-net/codeg. Create publication-quality scientific diagrams using Nano Banana 2 AI with smart iterative refinement.

When should I use Scientific Schematics?

Scientific Schematics fits situations like: tasks that involve Data visualization; tasks that involve Diagrams; tasks that involve Image generation.

How do I install Scientific Schematics in Claude Code?

Run `npx skills add spacering-net/codeg --skill scientific-schematics -a claude-code`. Or copy the skill folder (src-tauri/science/skills/scientific-schematics in spacering-net/codeg) into .claude/skills/scientific-schematics in your project. Claude Code loads it when a task matches its description.

How do I install Scientific Schematics in Codex?

Run `npx skills add spacering-net/codeg --skill scientific-schematics -a codex`. Or copy the skill folder (src-tauri/science/skills/scientific-schematics in spacering-net/codeg) into .agents/skills/scientific-schematics in your project. Codex loads it when a task matches its description.

Can I use Scientific Schematics in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add spacering-net/codeg --skill scientific-schematics -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/scientific-schematics, .gemini/skills/scientific-schematics, .github/skills/scientific-schematics and .opencode/skills/scientific-schematics in your project.

What does Scientific Schematics need to run?

Going by SKILL.md and its folder, Scientific Schematics needs Python and a shell for the scripts in its folder, the command-line tools its instructions call (python) and credentials named OPENROUTER_API_KEY. Our summary lists: Python 3; A Bash shell; A credential in OPENROUTER_API_KEY. Its frontmatter pre-approves these tools: Read, Write, Edit, Bash.

Does Scientific Schematics access the network?

SKILL.md names 7 domains. In commands or code: openrouter.ai; the agent is likely to contact it when it follows the instructions. As links in the text: schemdraw.readthedocs.io, networkx.org, matplotlib.org, nature.com, science.org and consort-statement.org. This is read from the text; nothing was executed.

Is Scientific Schematics safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Scientific Schematics use?

Scientific Schematics is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Scientific Schematics use?

About 5.9k tokens (SKILL.md is roughly 24k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 7.4k tokens, read only when the agent opens those files.

What are the alternatives to Scientific Schematics?

Skills that share tags, products or a category with Scientific Schematics: Scientific Schematics (K-Dense-AI/claude-scientific-writer, 2.4k stars), Scientific Schematics (K-Dense-AI/scientific-agent-skills, 48k stars), Paper Figure Generate (GRIND-Lab-Core/night_owl_research_agent, 106 stars) and Engineering Figure Agent (heyu-233/engineering-figure-agent, 307 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Scientific Schematics?

spacering-net (a GitHub organization) maintains it in spacering-net/codeg, which has 3,874 GitHub stars. The repository holds 10 skills in this directory. The repository was last updated on October 10, 2026.

Source: spacering-net/codeg on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.