Scientific Schematics
K-Dense-AI/claude-scientific-writer
Create publication-quality scientific diagrams using Nano Banana 2 AI with smart iterative refinement.
Create publication-quality scientific diagrams using Nano Banana 2 AI with smart iterative refinement.
$ npx skills add spacering-net/codeg --skill scientific-schematics -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install spacering-net/codeg scientific-schematics --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ 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-srcUse ~/.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/
Install the "scientific-schematics" agent skill from https://github.com/spacering-net/codeg/tree/main/src-tauri/science/skills/scientific-schematics into .claude/skills/scientific-schematics/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "scientific-schematics", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/spacering-net/codeg/tree/main/src-tauri/science/skills/scientific-schematicsType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add spacering-net/codeg --skill scientific-schematics -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install spacering-net/codeg scientific-schematics --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/spacering-net/codeg.git skills-src && mkdir -p .agents/skills && cp -r skills-src/src-tauri/science/skills/scientific-schematics .agents/skills/scientific-schematics && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "scientific-schematics" agent skill from https://github.com/spacering-net/codeg/tree/main/src-tauri/science/skills/scientific-schematics into .agents/skills/scientific-schematics/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "scientific-schematics", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add spacering-net/codeg --skill scientific-schematics -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install spacering-net/codeg scientific-schematics --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/spacering-net/codeg.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/src-tauri/science/skills/scientific-schematics .cursor/skills/scientific-schematics && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "scientific-schematics" agent skill from https://github.com/spacering-net/codeg/tree/main/src-tauri/science/skills/scientific-schematics into .cursor/skills/scientific-schematics/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "scientific-schematics", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/spacering-net/codeg.git --path src-tauri/science/skills/scientific-schematics--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add spacering-net/codeg --skill scientific-schematics -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install spacering-net/codeg scientific-schematics --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/spacering-net/codeg.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/src-tauri/science/skills/scientific-schematics .gemini/skills/scientific-schematics && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "scientific-schematics" agent skill from https://github.com/spacering-net/codeg/tree/main/src-tauri/science/skills/scientific-schematics into .gemini/skills/scientific-schematics/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "scientific-schematics", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install spacering-net/codeg scientific-schematicsInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add spacering-net/codeg --skill scientific-schematics -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/spacering-net/codeg.git skills-src && mkdir -p .github/skills && cp -r skills-src/src-tauri/science/skills/scientific-schematics .github/skills/scientific-schematics && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "scientific-schematics" agent skill from https://github.com/spacering-net/codeg/tree/main/src-tauri/science/skills/scientific-schematics into .github/skills/scientific-schematics/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "scientific-schematics", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add spacering-net/codeg --skill scientific-schematics -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install spacering-net/codeg scientific-schematics --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/spacering-net/codeg.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/src-tauri/science/skills/scientific-schematics .opencode/skills/scientific-schematics && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "scientific-schematics" agent skill from https://github.com/spacering-net/codeg/tree/main/src-tauri/science/skills/scientific-schematics into .opencode/skills/scientific-schematics/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "scientific-schematics", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
scientific-schematicsCreate 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. 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.
5 steps, taken from the first numbered list in SKILL.md.
Read from SKILL.md and the folder at commit 05905cc. It shows what the files ask for, not the result of running them.
Pre-approves these tools, so the agent can use them without asking each time:
ReadWriteEditBashFrom allowed-tools in the SKILL.md frontmatter.
Ships 3 files in scripts/ (Python and Shell), which the agent can run.
Shell commands in SKILL.md call:
pythonFrom the folder's file list and the shell code blocks in SKILL.md.
Hosts in commands or code, which the agent is likely to contact:
openrouter.aiAlso links to:
schemdraw.readthedocs.ionetworkx.orgmatplotlib.orgnature.comscience.orgconsort-statement.orgFrom URLs in SKILL.md, links to its own repository left out.
Names these keys or tokens, usually read from environment variables:
OPENROUTER_API_KEYFrom names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
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.
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.
The automated check noted patterns worth knowing about, such as sudo or a known installer.
allowed-tools: Read, Write, Edit, BashAutomated 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.
The full file from spacering-net/codeg at commit 05905cc, republished under its MIT licence (© spacering-net). 1,748 words, ~5,949 tokens.
.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.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:
Quality Thresholds by Document Type:
| Document Type | Threshold | Description |
|---|---|---|
| journal | 8.5/10 | Nature, Science, peer-reviewed journals |
| conference | 8.0/10 | Conference papers |
| thesis | 8.0/10 | Dissertations, theses |
| grant | 8.0/10 | Grant proposals |
| preprint | 7.5/10 | arXiv, bioRxiv, etc. |
| report | 7.5/10 | Technical reports |
| poster | 7.0/10 | Academic posters |
| presentation | 6.5/10 | Slides, talks |
| default | 7.5/10 | General 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.
Create any scientific diagram by simply describing it. Nano Banana 2 handles everything automatically with smart iteration:
# 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 journalWhat happens behind the scenes:
Smart Iteration Benefits:
Output: Versioned images plus a detailed review log with quality scores, critiques, and early-stop information.
Set your OpenRouter API key:
export OPENROUTER_API_KEY='your_api_key_here'Get an API key at: https://openrouter.ai/keys
Effective Prompts for Scientific Diagrams:
✓ Good prompts (specific, detailed):
✗ Avoid vague prompts:
Key elements to include:
Scientific Quality Guidelines (automatically applied):
This skill should be used when:
Simply describe your diagram in natural language. Nano Banana 2 generates it automatically:
python scripts/generate_schematic.py "your diagram description" -o output.pngThat's it! The AI handles:
Works for all diagram types:
No coding, no templates, no manual drawing required.
The AI generation system uses smart iteration - it only regenerates if quality is below the threshold for your document type:
┌─────────────────────────────────────────────────────┐
│ 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 │
└─────────────────────────────────────────────────────┘Prompt Construction:
Scientific diagram guidelines + User requestOutput: diagram_v1.png
Gemini 3.1 Pro Preview evaluates the diagram on:
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)| If Score... | Action |
|---|---|
| >= threshold | STOP - Quality is good enough for this document type |
| < threshold | Continue to next iteration with improved prompt |
Example:
If quality is below threshold, the system:
All iterations are saved with a JSON review log that includes early-stop information:
{
"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!
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']}")# 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 -v1. 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"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.pngpython 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 2python 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.pngpython 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.pngThe main entry point for generating scientific schematics:
# 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 -vNote: 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.
\includegraphics{} for generated imagesProblem: Overlapping text or elements
--iterations 2 for better refinementProblem: Elements not connecting properly
Problem: Export quality poor
--iterations 2Problem: Elements overlap after generation
--iterations 2 for better refinementProblem: False positive overlap detection
detect_overlaps(image_path, threshold=0.98)Problem: Generated image quality is low
--iterations 2Problem: Colorblind simulation shows poor contrast
Problem: High-severity overlaps detected
Problem: Visual report generation fails
Image.open(path).verify()Problem: Colors indistinguishable in grayscale
verify_accessibility(image_path)Problem: Text too small when printed
validate_resolution(image_path)Problem: Accessibility checks consistently fail
Load these files for comprehensive information on specific topics:
references/best_practices.md - Publication standards and accessibility guidelinesPython Libraries
Publication Standards
This skill works synergistically with:
Before submitting diagrams, verify:
run_quality_checks() and achieved PASS statusquality_reports/ directory\ref{} points to correct figure)# Required
export OPENROUTER_API_KEY='your_api_key_here'
# Get key at: https://openrouter.ai/keysSimplest possible usage:
python scripts/generate_schematic.py "your diagram description" -o output.pngUse 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
SKILL.md and 6 other files (scripts, references) in src-tauri/science/skills/scientific-schematics of spacering-net/codeg.
Open the folder on GitHubat commit 05905cc
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.
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.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Scientific Schematics this skillspacering-net/codeg | 3.9k | 11 repos | ~5.9k | Automated safety check: Notes | MIT | |
| Scientific SchematicsK-Dense-AI/claude-scientific-writer | 2.4k | 1 repos | ~4.3k | Automated safety check: Notes | MIT | |
| Scientific SchematicsK-Dense-AI/scientific-agent-skills | 48k | 1 repos | ~5.1k | Automated safety check: Notes | MIT | |
| Paper Figure GenerateGRIND-Lab-Core/night_owl_research_agent | 106 | — | ~5.1k | Automated safety check: Notes | None | |
| Engineering Figure Agentheyu-233/engineering-figure-agent | 307 | — | ~1.1k | Automated safety check: Pass | MIT | |
| Generate ImageK-Dense-AI/claude-scientific-writer | 2.4k | 1 repos | ~3.8k | Automated safety check: Notes | MIT |
K-Dense-AI/claude-scientific-writer
Create publication-quality scientific diagrams using Nano Banana 2 AI with smart iterative refinement.
K-Dense-AI/scientific-agent-skills
Generates scientific diagram drafts using Nano Banana 2 AI with smart iterative refinement.
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).
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…
K-Dense-AI/claude-scientific-writer
Generate or edit images with AI models through the OpenRouter Image API (Gemini, Seedream, Recraft, GPT-Image, Riverflow).
Muuuun/luxas
Hybrid figure pipeline (Nano Banana raster + rembg background removal + TikZ vector assembly).
spacering-net/codeg
Perform comprehensive exploratory data analysis on scientific data files across 200+ file formats.
spacering-net/codeg
Structured hypothesis formulation from observations. An agent skill from spacering-net/codeg.
spacering-net/codeg
Structured manuscript/grant review with checklist-based evaluation.
spacering-net/codeg
Guided statistical analysis for research data - test selection, assumption checking, effect sizes, power analysis, Bayesian alternatives, and APA-formatted reporting.
spacering-net/codeg
Systematically evaluate scholarly work using the ScholarEval framework, providing structured assessment across research quality dimensions including problem formulation, methodology, analysis, and…
spacering-net/codeg
Sample-size and statistical power calculations for planning studies.
Works with
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.
Scientific Schematics fits situations like: tasks that involve Data visualization; tasks that involve Diagrams; tasks that involve Image generation.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.