ComposerSAFE
Systematic framework for planning and writing academic papers using Claude Code. Includes strategist (planning) and composer (writing) skills with quality checkpoints.
Overview
Systematic framework for planning and writing academic papers using Claude Code. Includes strategist (planning) and composer (writing) skills with quality checkpoints.
db8e16b76f96OBSERVED · 2026-10-12What it tells the agent
The instruction file, verbatim from the audited commit — this is the text the model reads, and the surface the audit's instruction layer examines. Quoted here so you can judge it without cloning anything.
---
name: academic-paper-composer
description: Systematic writing framework for philosophy and interdisciplinary academic papers from optimized outline to submission-ready manuscript. Use when users want to: (1) write a paper from a detailed outline, (2) ensure quality control during writing, (3) maintain consistency across chapters, (4) prepare a submission-ready manuscript, or (5) systematically execute a planned paper. Triggered by phrases like 'write the paper from this outline,' 'compose the full manuscript,' 'execute the outline,' or when users have completed strategic planning (academic-paper-strategist skill) and are ready to write. Takes optimized outline as input; outputs complete manuscript with iterative quality checks.
---
# Academic Paper Composer
## Overview
This skill provides a systematic framework for writing academic papers from optimized outline to submission-ready manuscript. It implements iterative quality control at both chapter-level and paper-level, ensuring consistent high quality throughout the writing process.
**Input**: Detailed, optimized paper outline (from academic-paper-strategist or equivalent)
**Output**: Complete, submission-ready manuscript with quality validation reports
**Prerequisite**: Use **academic-paper-strategist** skill first to create optimized outline (or provide equivalent detailed outline)
---
## When to Use This Skill
Use **academic-paper-composer** when you need to:
**Writing Stage**:
- Execute a detailed paper outline systematically
- Write a complete academic paper chapter-by-chapter
- Maintain quality control during writing process
- Ensure consistency across all sections
**Quality Assurance Stage**:
- Validate each chapter before proceeding
- Check cross-chapter coherence
- Perform final quality assessment
- Verify submission readiness
**Submission Preparation Stage**:
- Prepare manuscript for platform submission
- Complete platform-specific checklists
- Generate final submission package
**Triggers**:
- "Write the paper from this outline"
- "Compose the full manuscript"
- "Execute the outline systematically"
- "I have an outline, help me write the paper"
- After completing academic-paper-strategist skill
---
## Workflow Overview
```
Phase 4: SYSTEMATIC WRITING (Chapter-by-Chapter + Quality Gates)
↓
Phase 5: QUALITY CONTROL (Final Validation + Submission Prep)
↓
Output: Submission-Ready Manuscript + Quality Reports
```
**Quality Gates**: After each chapter + final paper evaluation
---
## Required Input
Before using this skill, you must provide:
### 1. Optimized Detailed Outline
**Required structure**:
```markdown
## Abstract (250-300 words)
- [Key points to cover]
## 1. Introduction (1,500 words)
### 1.1 Opening Puzzle (400 words)
- [Content guidance]
### 1.2 Literature Review (600 words)
- [Theories to discuss]
### 1.3 This Paper's Contribution (500 words)
- [Specific claims]
## 2. [Main Chapter Title] (1,200 words)
### 2.1 [Section] (400 words)
- [Argument structure]
- [Key citations]
...
[Complete structure with word counts and content guidance]
```
**Quality check**: Outline should specify:
- ✓ Chapter titles and word counts
- ✓ Subsection structure (to 3rd level)
- ✓ Content guidance for each section
- ✓ Key citations to include
- ✓ Argument structure notes
If outline lacks these, consider using **academic-paper-strategist** first.
### 2. Platform Writing Standards Guide
**From academic-paper-strategist Phase 1**, or equivalent document specifying:
- Platform style patterns (voice, terminology, citation format)
- Structural conventions
- Example papers for reference
### 3. Literature Base (Optional but Recommended)
- List of core papers to cite
- Research gap analysis
- Key concepts to emphasize
---
## Phase 4: Systematic Writing
### Goal
Write complete manuscript chapter-by-chapter with iterative quality control.
### Workflow
#### Step 4.1: Writing Environment Setup
Before writing, I will:
1. **Verify outline completeness**:
- All chapters specified with word counts
- Content guidance provided
- Argument structure clear
2. **Load reference documents**:
- Platform writing standards
- Section writing guides (`references/section_guides.md`)
- Quality standards (`references/writing_standards.md`)
3. **Create writing tracker**:
```markdown
# Writing Progress Tracker
- [ ] Abstract (250 words)
- [ ] Chapter 1: Introduction (1,500 words)
- [ ] Chapter 2: [Title] (1,200 words)
...
- [ ] Conclusion (1,000 words)
- [ ] References
```
**Decision Point 1**: Confirm outline and standards loaded, ready to begin writing.
#### Step 4.2: Chapter-by-Chapter Writing
**For each chapter, I will follow this sequence**:
##### A. Pre-Writing Review
Before writing chapter N:
1. **Review outline specification** for this chapter:
- Word count target
- Subsection structure
- Content guidance
- Key arguments/citations
2. **Review previous chapter** (if N>1):
- Last paragraph of chapter N-1
- Key concepts introduced
- Promises to fulfill
3. **Check section guide**:
- Load appropriate template from `references/section_guides.md`
- Review quality markers for this section type
##### B. Writing Execution
I will write the chapter following:
**Content principles**:
- **Follow outline exactly**: Respect structure and word counts
- **Include specified citations**: Use literature from outline
- **Maintain platform style**: Match voice and terminology
- **Use section templates**: Follow appropriate guide from `section_guides.md`
**Quality targets (pre-emptive)**:
- Argument quality: Clear thesis, justified premises
- Citation quality: All claims supported, proper format
- Clarity: Precise prose, terms defined, good transitions
- Structure: Logical flow, proper proportions
- Style conformity: Match platform conventions
**Output**: Complete chapter draft
##### C. Post-Writing Evaluation
After completing chapter draft, I will:
1. **Create evTrust audit
SAFEgrade B · trust 89/100 Nothing in the source contradicts what it says it does. Grade A is reserved for packages that have also passed the behavioural sandbox.
| Layer | What it checks | Result |
|---|---|---|
| L0 | Provenance & inventory | PASS |
| L1 | Static analysis of the code | PASS |
| L2 | Instruction surface (what it tells the agent) | PASS |
| L3 | Class-specific surface | PASS |
| L4 | Behavioural (sandbox) | SKIPPED |
What the source does
- Filesystem
- none-observed
- Network
- none-observed
- Shell
- none-observed
- Dependencies
- pinned
- Secrets in source
- none-found
Findings (0)
No findings outside the package's declared scope.
Gates applied: no_behavioural_pass.
db8e16b76f96full audit observations/trust-audit/skill/lishix520__composer.json · Report an issue / request a re-scanAudit history
Every audit this skill has had.
| Date | Source | Verdict | Grade | Score | Change |
|---|---|---|---|---|---|
| 2026-10-12 | db8e16b76f96 | SAFE | B | 89 | first audit |
Questions
What does the Composer skill do?
Systematic framework for planning and writing academic papers using Claude Code. Includes strategist (planning) and composer (writing) skills with quality checkpoints.
Is Composer safe to install?
The audit found nothing in the source that contradicts what it says it does, and graded it B (89/100). Grade A is held back for packages that have also passed a sandboxed behavioural run, which is why a clean skill reads B.
What can Composer access on my machine?
The audit observed no filesystem, network or shell use at all in its source.
How current is this page?
The grade is for one exact copy of the source (db8e16b76f96), read on 2026-10-12. The repository is watched, and a new audit runs when it changes — this is the first audit.