---
name: graphical-abstract
description: Turn a paper or results summary into an accurate, accessible graphical abstract as editable SVG — choose the figure type, compose it, then audit palette contrast, greyscale separation and colour-vision safety before submission.
category: communication
license: CC-BY-4.0
author: Heureka Labs
version: 1.1.0
tags: [graphical-abstract, figures, accessibility, svg, publishing]
datasets: []
allowed-tools: Read, Write, Edit, Bash
verified:
date: 2026-08-18
against: Python 3.11.15, standard library only
executed: 7
unverified: 0
---
# Graphical Abstract
## Overview
A graphical abstract is the most-read figure in a paper and the one most often
made badly. The failure mode is rarely draughtsmanship. It is cramming every
interaction into one frame, choosing colours that die in greyscale or under
red-green colour vision deficiency, and — the one that actually damages the
science — drawing mechanism the results do not support.
This skill encodes the judgement, not the drawing. It works in two modes:
- **create** — build a graphical abstract from a paper, manuscript draft, or
results summary.
- **critique** — score an existing figure against the same checklist without
redrawing it.
Output is **SVG**, deliberately. The author must be able to open the figure and
correct the science by hand, keep the text selectable and searchable, and scale
it to a journal column without resampling. A raster image is a dead end: an
error in it can only be fixed by regenerating the whole thing.
## When to use this skill
- Drafting a graphical abstract, visual abstract, or summary figure for a
manuscript or preprint
- Reviewing a figure for accessibility before submission
- Adapting one figure for a different audience — clinicians, a policy brief, a
conference slide, a lay summary
- Checking whether a palette survives greyscale printing and colour vision
deficiency
**Not** for data plots with axes and quantitative encodings — those are charts,
governed by the data, and belong to a plotting workflow. This skill covers
schematic figures whose content is the argument.
## The one rule that outranks the rest
**Never draw a step the source does not state.** A graphical abstract is read
as a claim about the biology. If the results show that a knockout reduces flux
and do not identify the intermediate, the figure shows the knockout and the
reduced flux — not a guessed intermediate, not a speculative arrow, not a
mechanism assembled to make the picture look complete.
When the source is silent, the correct outputs are an honest gap, a dashed
"proposed" arrow explicitly labelled as such, or a question put back to the
author. Never a confident arrow.
Two supporting rules follow from it:
- **Do not upgrade correlation to causation with an arrowhead.** An association
is a line or a bracket. An arrow asserts direction.
- **Do not invent quantities.** No axis, no "3-fold", no percentage that is not
in the source.
---
## Mode: create
### Step 0 — Gate on the journal's policy, before drawing anything
Journal policies on AI-assisted and AI-generated imagery differ sharply and
change often. Some publishers prohibit generated imagery in figures outright,
some permit it with a declaration, some distinguish between generated artwork
and AI-assisted layout of author-supplied elements.
Ask the author for the target journal, then **read that journal's current
policy** rather than relying on memory or on this file — anything written here
would be stale within a year. Search the publisher's author guidelines for
"artificial intelligence", "generative AI", or "AI-generated images".
Resolve to one of three outcomes and say which:
| Finding | Action |
|---|---|
| Generated imagery prohibited | Stop. Produce the composition plan, palette and layout as a specification the author draws or commissions. Do not emit the figure. |
| Permitted with disclosure | Proceed, and deliver the declaration from Step 6 with the figure. |
| Policy not found or unclear | Proceed, flag it prominently, and tell the author to confirm before submission. |
If the author has no target journal yet, proceed and note that the gate is
deferred, not passed.
See `references/journal-policy.md` for what to search for and how to record it.
### Step 1 — Fix the single claim
Write, in one sentence, the claim the figure makes. Not the paper's topic — the
claim. "Loss of CPT1A blocks fatty acid oxidation, and medium-chain
supplementation restores it" is a claim. "Metabolic regulation in hepatocytes"
is a topic and cannot be drawn.
If the sentence needs an "and" joining two independent findings, the figure is
carrying two claims. Pick one, or split into two figures. Everything that does
not serve the chosen claim is cut in Step 4.
### Step 2 — Classify the figure type
The type determines the canonical composition. Six cover nearly everything:
**mechanism**, **process**, **experimental setup**, **workflow**,
**comparison**, **timeline**.
Read `references/figure-types.md` for each type's reading order, the layout it
implies, and its characteristic failure. Choosing the wrong type is the most
common structural error — a comparison drawn as a mechanism forces the reader
to hunt for the contrast that is the entire point.
### Step 3 — Fix the audience
The same result is drawn differently for different readers. State the audience
explicitly, because it changes what leads and what is cut:
| Audience | Leads with | Detail level | Terminology |
|---|---|---|---|
| Domain specialist | The mechanism or the novel step | Molecular, named entities | Gene and protein names, unexpanded |
| Adjacent researcher | The system-level result | Pathway, cell, tissue | Names expanded once |
| Clinician | The phenotype or outcome | Organ, patient, endpoint | Clinical vocabulary, few gene names |
| Policymaker or press | The consequence | One level, no molecules | Plain language throughout |
| Student | The logic of the experiment | Stepwise, nothing skipped | Everything defined |
### Step 4 — Compose
Apply all six, in order. Each is checkable in Step 5.
**Colour — semantic, limited, luminance-laddered.** Use at most three
meaning-bearing colours. Assign them roles and keep the roles consistent across
every panel of the figure. The validated default palette:
| Role | Colour | Contrast on white |
|---|---|---|
| Ink — text, outlines, arrows | `#111111` | 18.88:1 |
| Baseline, normal, healthy, control | `#1b4965` | 9.60:1 |
| Perturbation, disease, treatment | `#ca6702` | 3.85:1 |
| Context — de-emphasized scaffolding | `#d9d9d9` | non-meaning-bearing, exempt |
This triple is verified in Step 5 to hold at least 1.90:1 separation between
every pair, including after protanopia and deuteranopia simulation. Warm reads
as perturbation and cool as baseline, which is the convention most readers
already carry.
If you deviate, run the audit — do not assume. Red-green pairs in particular
fail: the common `#d62728` / `#2ca02c` pair collapses to 1.16:1 under
deuteranopia, effectively one colour.
**Redundant encoding — colour is never the only channel.** Every distinction
carried by colour must also be carried by a label, a shape, or a position. This
is the rule that makes the figure work in greyscale, under every form of colour
vision deficiency, and when photocopied. Around 8% of men and 0.5% of women of
Northern European ancestry have red-green colour vision deficiency, so a
hue-only distinction is illegible to a substantial slice of any readership.
**Composition — one reading path.** Horizontal for a sequence, vertical for a
hierarchy or a gradient, cyclic for a loop that genuinely returns to its start,
forking for a decision or a divergence. Pick one and let the eye run it once,
left to right or top to bottom. Two competing paths in one frame is the second
most common structural error.
**Opacity — push context back.** Cells, organs, vessels and environments are
scaffolding, not content. Draw them at 30–40% opacity in a single neutral so
the central interaction is unambiguously dominant. If everything is at full
strength, nothing is emphasized.
**Restraint — variation must carry meaning.** At most four font sizes, three
stroke widths, and two arrowhead styles in the whole figure. Every distinct
value must correspond to a distinct meaning. A second arrowhead style that
means nothing costs the reader a moment of wondering what it means.
**Negative space — a clean background.** No gradient, no texture, no drop
shadow, no decorative border. White or transparent. Space around a group is how
the reader knows it is a group.
### Step 5 — Audit before returning
Not optional and not advisory. Write out both tools from
`references/accessibility-audit.md`, then run them:
```bash
python3 svg_lint.py figure.svg
python3 palette_audit.py '#ffffff' '#111111' '#1b4965' '#ca6702'
```
`svg_lint.py` checks the structure — viewBox present, no embedded raster, text
still live rather than outlined, a `` for screen readers, and the
restraint caps from Step 4. It prints every hex colour it finds, which is where
the second command's arguments come from — but **select them, do not paste the
list**. Pass the background once, as the first argument, then only the
meaning-bearing colours. The background repeated scores 1.00:1 against itself
and the scaffolding neutral is faint by design, so handing over the raw list
fails a figure that is correct. `references/accessibility-audit.md` works this
through, and `## Try it` below runs both selections so you can see the
difference.
`palette_audit.py` checks the colours — WCAG 2.2 contrast against the
background, pairwise greyscale separation, and what each pair becomes under
protanopia and deuteranopia.
Both exit non-zero on failure. **Fix and re-run until both pass.** Do not
report a figure as finished while either is failing; report the failure instead.
Then check by eye what no tool can:
- Does the reading path run once, in the intended order?
- Would a reader outside the subfield get the claim in ten seconds?
- Are gene names italic and protein names roman, consistently?
- Are units, scale bars, and every abbreviation defined in the figure?
- Is every arrow supported by the source?
### Step 6 — Return with the accountability line
Deliver four things:
1. The SVG.
2. The design rationale — figure type, audience, palette roles, what was cut
and why.
3. The audit output, pasted, both tools passing.
4. This line, verbatim, plus the declaration below if the journal requires one:
> Scientific accuracy is the author's responsibility. Every entity, arrow and
> label in this figure must be checked against the underlying results before
> submission.
`references/journal-policy.md` carries a declaration template to adapt.
---
## Mode: critique
Score an existing figure without redrawing it. If it is an SVG, run both tools
first — that settles structure and palette mechanically. Then judge what the
tools cannot, and report findings ordered by severity:
1. **Scientific accuracy** — is any drawn step unsupported by the source? Is
any correlation drawn as causation? Any invented quantity? These are
blocking; everything else is cosmetic beside them.
2. **Claim clarity** — is there one claim, and does the figure make it?
3. **Type and reading path** — right figure type, single unambiguous path?
4. **Accessibility** — contrast, greyscale separation, colour vision
deficiency, redundant encoding.
5. **Restraint and clutter** — font sizes, stroke widths, arrowheads, opacity.
6. **Labelling** — gene and protein formatting, units, scale bars,
abbreviations.
For each finding give the specific element, why it fails, and the concrete fix.
"Improve the contrast" is not a finding; "`#5b8e7d` against `#bc4b51` is 1.32:1
in greyscale, so the two arms are indistinguishable when printed — drop the
green to `#1b4965` for 1.95:1" is.
If the figure is a raster, say so first: the accessibility checks can still be
described but not run, and any correction means regenerating the figure.
## Try it
A self-contained check that this skill's own numbers still hold. No account, no key,
no network, and nothing to install — both tools are pure standard library.
**Data** — generated inline, and the frontmatter says so with `datasets: []` rather
than naming a source. There is nothing to fetch: the input to this skill is a figure
the author is drafting, and the audit is arithmetic over colour values plus a structural
read of the XML. The block writes a miniature graphical abstract built to Step 4 — three
meaning-bearing colours in fixed roles, context pushed back in a neutral, every colour
distinction also carried by a label — and audits that.
**Prerequisite** — write both tools from `references/accessibility-audit.md` into the
working directory as `svg_lint.py` and `palette_audit.py`. Step 5 of the create mode
does this anyway; the block below does the rest.
**Run**
```python
import subprocess, sys, textwrap
FIGURE = textwrap.dedent('''\
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 360 120">
<title>CPT1A loss blocks fatty acid oxidation; medium-chain supplementation restores itHepatocyte fatty acid oxidationControlCPT1A KOKO + MCTFAO downFAO restored
''')
open("figure.svg", "w").write(FIGURE)
PALETTE_AUDIT = r'''#!/usr/bin/env python3
"""Audit a figure palette for contrast, greyscale separation and dichromat safety.
Usage: python3 palette_audit.py BACKGROUND COLOUR [COLOUR ...]
Example: python3 palette_audit.py '#ffffff' '#1b4965' '#bc4b51' '#5b8e7d'
Pure standard library. No network, no install.
"""
import itertools
import sys
# --- sRGB / WCAG 2.2 -------------------------------------------------------
def hex_to_rgb(h):
s = h.strip().lstrip("#")
if len(s) == 3:
s = "".join(c * 2 for c in s)
if len(s) != 6 or any(c not in "0123456789abcdefABCDEF" for c in s):
raise ValueError(f"not a hex colour: {h!r}")
return tuple(int(s[i:i + 2], 16) for i in (0, 2, 4))
def srgb_to_linear(c):
c /= 255.0
return c / 12.92 if c <= 0.03928 else ((c + 0.055) / 1.055) ** 2.4
def luminance(h):
r, g, b = (srgb_to_linear(c) for c in hex_to_rgb(h))
return 0.2126 * r + 0.7152 * g + 0.0722 * b
def contrast(a, b):
la, lb = luminance(a), luminance(b)
lo, hi = sorted((la, lb))
return (hi + 0.05) / (lo + 0.05)
# --- dichromat simulation --------------------------------------------------
# Vienot, Brettel & Mollon (1999), applied in linear sRGB.
CVD = {
"protanopia": ((0.11238, 0.88762, 0.0), (0.11238, 0.88762, 0.0), (0.00401, -0.00401, 1.0)),
"deuteranopia": ((0.29275, 0.70725, 0.0), (0.29275, 0.70725, 0.0), (-0.02234, 0.02234, 1.0)),
}
def linear_to_srgb(c):
c = max(0.0, min(1.0, c))
v = c * 12.92 if c <= 0.0031308 else 1.055 * (c ** (1 / 2.4)) - 0.055
return round(max(0.0, min(1.0, v)) * 255)
def simulate(h, kind):
lin = [srgb_to_linear(c) for c in hex_to_rgb(h)]
m = CVD[kind]
return "#{:02x}{:02x}{:02x}".format(
*(linear_to_srgb(sum(m[i][j] * lin[j] for j in range(3))) for i in range(3)))
# --- thresholds ------------------------------------------------------------
TEXT_MIN = 4.5 # WCAG 2.2 SC 1.4.3, normal text
LARGE_MIN = 3.0 # SC 1.4.3, text >=18pt or >=14pt bold
NONTEXT_MIN = 3.0 # SC 1.4.11, meaningful graphical objects
PAIR_MIN = 1.5 # this skill's heuristic for greyscale separability -- NOT a WCAG rule
def main(argv):
if len(argv) < 3:
print(__doc__.strip())
return 2
bg, palette = argv[1], argv[2:]
try:
for c in [bg, *palette]:
hex_to_rgb(c)
except ValueError as e:
print(f"FAIL {e}")
return 2
failures = 0
print(f"background {bg} luminance {luminance(bg):.4f}\n")
print("-- vs background (SC 1.4.11 needs 3.0 for shapes, SC 1.4.3 needs 4.5 for body text)")
for c in palette:
r = contrast(c, bg)
tag = "ok " if r >= NONTEXT_MIN else "FAIL"
text = "text ok" if r >= TEXT_MIN else ("large text only" if r >= LARGE_MIN else "not usable for text")
if r < NONTEXT_MIN:
failures += 1
print(f" {tag} {c} {r:5.2f}:1 {text}")
print(f"\n-- pairwise greyscale separation (heuristic floor {PAIR_MIN}:1)")
for a, b in itertools.combinations(palette, 2):
r = contrast(a, b)
tag = "ok " if r >= PAIR_MIN else "WARN"
if r < PAIR_MIN:
failures += 1
print(f" {tag} {a} / {b} {r:5.2f}:1")
print("\n-- dichromat simulation (does the pair survive without hue?)")
for kind in ("protanopia", "deuteranopia"):
print(f" {kind}")
for a, b in itertools.combinations(palette, 2):
sa, sb = simulate(a, kind), simulate(b, kind)
r = contrast(sa, sb)
tag = "ok " if r >= PAIR_MIN else "WARN"
print(f" {tag} {a}->{sa} {b}->{sb} {r:5.2f}:1")
print(f"\n{'PASS' if failures == 0 else f'{failures} problem(s)'}")
return 0 if failures == 0 else 1
if __name__ == "__main__":
sys.exit(main(sys.argv))
'''
SVG_LINT = r'''#!/usr/bin/env python3
"""Lint a graphical abstract SVG for editability, restraint and accessibility.
Usage: python3 svg_lint.py figure.svg
Pure standard library. No network, no install.
"""
import re
import sys
import xml.etree.ElementTree as ET
SVG = "{http://www.w3.org/2000/svg}"
MIN_FONT = 9.0 # user units; below this is unreadable when scaled to column width
MAX_FONT_SIZES = 4 # heuristic: title, label, annotation, caption
MAX_STROKE_WIDTHS = 3 # heuristic: emphasis, normal, hairline
def tag(el):
return el.tag.split("}")[-1]
def colours_in(el):
out = set()
for attr in ("fill", "stroke", "stop-color"):
v = el.get(attr)
if v and v.startswith("#"):
out.add(v.lower())
style = el.get("style") or ""
for m in re.finditer(r"(?:fill|stroke|stop-color)\s*:\s*(#[0-9a-fA-F]{3,6})", style):
out.add(m.group(1).lower())
return out
def numeric(el, attr):
v = el.get(attr)
if v is None:
style = el.get("style") or ""
m = re.search(rf"{attr}\s*:\s*([0-9.]+)", style)
v = m.group(1) if m else None
if v is None:
return None
m = re.match(r"^([0-9.]+)", str(v).strip())
return float(m.group(1)) if m else None
def main(argv):
if len(argv) != 2:
print(__doc__.strip())
return 2
try:
tree = ET.parse(argv[1])
except ET.ParseError as e:
print(f"FAIL not well-formed XML — {e}")
return 1
except OSError as e:
print(f"FAIL cannot read file — {e}")
return 2
root = tree.getroot()
problems, notes = [], []
if tag(root) != "svg":
print(f"FAIL root element is <{tag(root)}>, expected