ssci-polish
Polish English academic papers for SSCI journal submission. This skill checks grammar, improves readability, and enhances academic tone
Install / Use
npx skills add brycewang-stanford/Auto-Empirical-Research-Skills --skill 70-ssci-polishInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Education & ResearchSupported Platforms
Tags
Our assessment of ssci-polish
ssci-polish scores 95/100 on our quality scale, 45th of 421 Education & Research skills we index (top 11%).
Its SKILL.md is 13 KB long, well organised into 23 sections with 5 code examples: a thorough specification that gives an agent plenty to work with.
With 4,360 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so ssci-polish is actively maintained.
- Our last check on 2026-11-15 found the source still online.
- No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
- Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-09-29. Automated pattern scan on 2026-09-28. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
ssci-polish compared with similar skills
All 4 of these similar skills score higher than ssci-polish; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| ssci-polish (this skill)by brycewang-stanford | 95 | 4.4k | 54d ago | SKILL.md |
| last30days-skillby mvanhorn | 100 | 68.0k | today | CLAUDE.md |
| x402by browser-use | 100 | 121.0k | 3d ago | SKILL.md |
| algorithmic-artby anthropics | 100 | 177.9k | 55d ago | SKILL.md |
| pptxby anthropics | 100 | 177.9k | 55d ago | SKILL.md |
Frequently asked questions
- How do I install ssci-polish?
- Run
npx skills add brycewang-stanford/Auto-Empirical-Research-Skills --skill ssci-polish. The install tabs above show the steps for each supported agent. - Which AI agents does ssci-polish work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is ssci-polish safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is ssci-polish still maintained?
- The repository was last updated about 2 months ago, so ssci-polish is actively maintained.
Skill content
View source on GitHubname: ssci-polish description: Polish English academic papers for SSCI journal submission. This skill checks grammar, improves readability, and enhances academic tone. Use when the user asks to polish, proofread, edit, or improve their English academic paper, manuscript, or article — especially when targeting SSCI, SCI, or other international journals. Also use when the user asks to "润色", "修改语法", "提升学术性", "polish my paper", or mentions their paper needs language improvement for journal submission. Always trigger on any request involving academic English polishing, even if the user doesn't explicitly say "SSCI." author: 刘松岐 | 辽宁大学 | copaper.ai团队培训班
SSCI Paper Language Polishing
作者: 刘松岐(辽宁大学)| copaper.ai 团队培训班学员
Polish English academic manuscripts for submission to SSCI/SCI journals. This skill integrates principles from three authoritative writing guides:
- Strunk & White, The Elements of Style (4th ed.) — grammar and fundamental writing rules
- Deirdre N. McCloskey, Economical Writing (3rd ed.) — clarity and style for economics and social sciences
- William Thomson, A Guide for the Young Economist (2nd ed.) — technical writing and notation standards
Workflow
When asked to polish a paper, follow this three-pass approach:
Pass 1: Grammar and Mechanics
Fix objective errors first:
- Subject-verb agreement, pronoun case, possessive forms
- Comma splices, sentence fragments, run-on sentences
- Misused words (affect/effect, imply/infer, disinterested/uninterested, etc.)
- Punctuation errors (commas, semicolons, colons, quotation marks)
- Spelling and typos
Refer to references/grammar.md for the complete grammar rule checklist.
Pass 2: Style and Readability
Improve clarity and fluency:
- Replace passive voice with active voice where possible
- Omit needless words (the single most important rule)
- Put statements in positive form; avoid "not" as evasion
- Use definite, specific, concrete language
- Express parallel ideas in parallel form
- Avoid elegant variation — use one word for one concept
- Place emphatic words at the end of sentences
- Split sentences > 40 words. Long sentences bury the main point and exhaust the reader (Thomson §4.3). Break them at logical pause points: before "and," "which," "while," "whereas," or between major clause boundaries. Aim for 15–25 words per sentence in results and methods sections. Exceptions: variable definition lists and questionnaire items in the data section.
- Remove qualifiers (very, rather, little, pretty)
- Remove boilerplate (This paper discusses..., The outline is as follows..., As we shall see...)
Refer to references/style.md for the complete style rule checklist.
Pass 3: Academic Tone and Technical Precision
Enhance academic rigor:
- Verify consistent and mnemonic notation
- Ensure all technical terms are defined before use
- Separate formal definitions from interpretations
- Present assumptions in decreasing order of plausibility
- State results before proofs; use consistent formats for theorems
- Use words, not just symbols, in key equations
- Ensure tables, graphs, and figures are self-explanatory with declarative titles
- Check that the literature review tells a story, not an enumeration
- Verify that the introduction is hook-driven, not "This paper..." boilerplate
- Remove academic pose (not only...but also, excessive however, due to, the fact that)
Refer to references/academic.md for the complete academic standards checklist.
Output Format
When polishing, show results in this structure:
Summary of Changes
Briefly list what was fixed at each pass level.
Polished Text
Present the full polished text. If only sections were edited, clearly mark which sections.
Change Log (optional, for tracking)
List specific changes with before/after comparisons for major revisions. Use this format:
- Line/Paragraph: brief reason →
"before"→"after"
Key Principles to Apply by Default
These rules from the three books should be applied in every polishing session unless the user specifies otherwise:
- Omit needless words (Strunk Rule 17) — the cardinal rule. Every word must tell.
- Use active voice (Strunk Rule 14) — We estimated the model... not The model was estimated...
- Be concrete (McCloskey Rule 27) — Prefer bread and beer to consumables, ships and spindles to capital equipment.
- One word, one meaning (McCloskey Rule 20) — Don't vary terms just for elegance.
- Express parallel ideas in parallel form (Strunk Rule 19) — The positive rule is X; the negative rule is Y.
- Place emphasis at the end (Strunk Rule 22) — The most important idea goes last.
- Write with nouns and verbs (Strunk Ch.V Reminder 4) — Adjectives and adverbs are secondary.
- Be clear above all (McCloskey Rule 4) — "Write not merely so that the reader can understand, but so that he cannot possibly misunderstand" (Quintilian).
Interaction Guidelines
- For short passages (<500 words): apply all three passes and present the full polished version.
- For full papers: ask the user whether to polish the whole document or specific sections. If the whole document, work section by section, starting with the abstract and introduction.
- Always explain the rationale behind major changes, referencing the specific rule from the source books.
- If the user's meaning is ambiguous, ask for clarification rather than guessing.
- Respect the author's voice — don't over-polish. The goal is clarity and correctness, not uniformity.
Important: What NOT to Change
- Technical terminology that is standard in the field
- Statistical/mathematical notation that is consistent and clearly defined
- Citations and reference format (unless obviously broken)
- The author's substantive arguments or conclusions
- Field-specific jargon that is necessary for precision (but flag it if a plainer alternative exists)
Additional Grammar Checks
Beyond the standard grammar rules, always verify:
- Sentence-initial capitalization: every word immediately after a period (
.) must begin with a capital letter, excluding abbreviations (e.g., i.e., e.g., etc., et al.). This applies to all prose paragraphs. - Consistent abbreviation casing: variable abbreviations in text (e.g., "Cr", "Inf") must match their definitions in tables exactly — do not change their case unless the table is also updated.
- Proper noun capitalization: "the Internet" (capitalized in formal academic writing), proper names of policies, institutions, and databases.
- Double spaces after periods within a sentence (e.g., between a citation and the next word) — these are typos, not the old typewriter convention.
- Sentence length: prose sentences exceeding 40 words must be split. Use this detection code during Step 2:
import re
for i, p in enumerate(doc.paragraphs):
for s in re.split(r'(?<=[.!?])\s+', p.text.strip()):
if len(s.split()) > 40:
print(f"P{i} ({len(s.split())}w): {s[:120]}...")
Only flag sentences in prose paragraphs (skip table cells, figure captions, and variable definition lists). Split at natural break points: before coordinating conjunctions (and, but, or), relative pronouns (which, that), or between major clause boundaries.
DOCX Editing Workflow
CRITICAL: Use python-docx, not hand-rolled XML surgery. The unpack→lxml→repack approach has a known bug where apply_tc corrupts text that spans multiple <w:t> elements, creating duplicate paragraph fragments. python-docx handles all OOXML internally and cannot introduce this class of bug.
Step 1: Read and Analyze
Use python-docx to extract ALL text (body + table cells):
from docx import Document
doc = Document("input.docx")
all_paras = list(doc.paragraphs)
for table in doc.tables:
for row in table.rows:
for cell in row.cells:
for para in cell.paragraphs:
all_paras.append(para)
for p in all_paras:
print(p.text)
Step 2: Apply Three-Pass Check
Go through ALL paragraphs systematically against the grammar.md, style.md, and academic.md checklists. Document every issue found, then compile the final change list. Only include changes that are definite errors or clear improvements — do not over-polish.
Step 3: Apply Changes (python-docx, format-preserving)
CRITICAL: Before clearing any paragraph, capture its original formatting from the first run. Apply this formatting to all new runs so the output matches the original document.
from docx.shared import Pt, RGBColor, Emu
from docx.oxml.ns import qn
RED = RGBColor(0xFF, 0x00, 0x00)
def get_para_format(para):
"""Capture font name, size, and bold/italic from the paragraph's first run."""
if para.runs:
first = para.runs[0]
return {
'name': first.font.name,
'size': first.font.size,
'bold': first.font.bold,
'italic': first.font.italic,
}
# Fallback: use paragraph style defaults
style = para.style
return {
'name': style.font.name if style.font.name else 'Times New Roman',
'size': style.font.size if style.font.size else Pt(12),
'bold': style.font.bold if style.font.bold else False,
'italic': style.font.italic if style.font.italic else False,
}
def apply_format(run, fmt):
"""Apply captured formatting to a run."""
if fmt['name']: run.font.name = fmt['name']
if fmt['size']: run.font.size = fmt['size']
run.font.bold = fmt['bold']
run.font.italic = fmt['italic']
for old, new in CHANGES:
for para in all_paras:
idx = para.text.find(old)
if idx == -1: continue
fmt = get_para_format(para)
before = para.text[:idx]
after = para.text[idx + len(old):]
# para.clear() preserves paragraph-level formatting
# (alignment, spacing, indentation) but removes all runs
para.clear()
if before:
r = para.add_run(before)
apply_format(r, fmt)
r = para.add_run(new)
apply_format(r, fmt)
r.font.color.rgb = RED
if after:
r = para.add_run(after)
apply_format(r, fmt)
break
Why this preserves formatting:
para.clear()keeps paragraph-level properties (<w:pPr>): alignment, line spacing, indentation, widow control.get_para_format()reads the original font name, size, bold, and italic from the paragraph's first run before clearing.- Each new run gets this captured formatting applied, so the output matches the original.
- Table cell paragraphs are handled the same way — each cell's formatting is captured independently.
Step 4: Verify Before Saving
# Check for duplicate paragraphs
seen = {}
for i, p in enumerate(all_paras):
txt = p.text.strip()
if len(txt) > 150 and txt in seen:
print(f"WARNING: P{seen[txt]} == P{i}")
else:
seen[txt] = i
# Check key phrases haven't multiplied
import re
for phrase in ["access to and understanding", "new-type agricultural"]:
count = sum(1 for p in all_paras if phrase in p.text)
# Count should not exceed expected occurrences
doc.save("output.docx")
Step 5: Save
doc.save("output.docx")
Limitations of This Approach
- Inline mixed formatting (e.g., part of a paragraph bold, part italic) is simplified to the paragraph's primary formatting. For academic papers where body text is uniform, this is acceptable.
- Changes are marked with red font color (not Word Track Changes). This is more reliable across Word versions and avoids XML corruption.
- Images, equations, headers, footers, page layout, paragraph spacing, and alignment are fully preserved.
Common Pitfalls
- Never use unpack→lxml→hand-edit→repack for tracked changes. The
apply_tcfunction that inserts<w:del>and<w:ins>corrupts text spanning multiple
Truncated for display — read the full file on GitHub.
Related Skills
last30days-skill
68.0kAI agent skill that researches any topic across Reddit, X, YouTube, HN, Polymarket, and the web - then synthesizes a grounded summary
x402
121.0kSet up Browser Use Cloud payments with x402 — pay per request from a crypto wallet (USDC on Base mainnet), no signup or API key.
algorithmic-art
177.9kCreating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems.
pptx
177.9kUse this skill any time a .pptx or .potx file is involved in any way — as input, output, or both. This includes: creating slide decks, pitch decks, or presentations; reading, parsing, or extracting text from any .pptx or .potx file (even if the extracted content will be used elsewhere, like in an em…
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
