# Paper Engineering

> Automated academic writing assistant based on a three-layer architecture: Framework Layer, Summary Layer, and Body Layer. Organizes all files in a structured project directory.

- Skill: `modbender/paper-engineering` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add modbender/paper-engineering`
- Raw SKILL.md: https://api.skillmd.com/api/skills/modbender/paper-engineering/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: modbender (https://skillmd.com/u/modbender)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/modbender/paper-engineering

---



# Paper Engineering Assistant

## 1. Skill Description
This skill automates a structured academic writing workflow based on a three-layer architecture: **Framework Layer**, **Summary Layer**, and **Body Layer**. It maintains data consistency across all layers through automatic synchronization mechanisms. The skill operates within a user-designated project directory (default: `./PaperProject/`).

## 2. When to Use
Use this skill when the user needs systematic assistance with academic writing, especially for long-form documents like theses or dissertations.
- User says: "Start working on my thesis."
- User says: "Read and structure all literature in the `references` folder."
- User says: "Generate a preliminary framework based on my research proposal."
- User says: "I've modified Section 2.1, please sync the framework and summaries."
- User says: "Find and download recent literature about 'performance management'."

## 3. Core Concepts & Workflow
This skill strictly follows the three-layer architecture:

### **A. Core Three-Layer Structure**
1.  **Framework Layer (`structs.json`)**: The blueprint/map of the entire paper. A JSON array describing the hierarchical structure of chapters, sections, and paragraphs with IDs, titles, abstracts, keywords, and key points.
2.  **Summary Layer (`summaries.json`)**: The content database. Provides detailed summaries for each framework node and records related node IDs for content traceability.
3.  **Body Layer (`./document_body/` directory)**: The actual written content. A directory and Markdown file collection that exactly mirrors the framework layer structure, with each file corresponding to a writing unit.

### **B. Workflow Stages**
**Stage 1: Literature Review & Processing**
1.  **Initialization**: Create necessary subdirectories in the project directory (e.g., `./document_body/`, `./processed_references/`).
2.  **Process References**:
    - Iterate through each reference in the `references` directory.
    - Create a dedicated folder for each reference (named after the reference) and initialize an `information.md` file with metadata (title, author, abstract, keywords, download link).
    - If the reference file (e.g., PDF) is available, parse it using the same three-layer architecture, generating corresponding `structs.json`, `summaries.json`, and body files stored within that reference's folder. This creates a "knowledge base" for each reference.
    - If the original text cannot be downloaded, only save the `information.md`.
3.  **Read Other Materials**: Review non-reference materials like research proposals, institutional guidelines, etc., to understand requirements and existing foundations.

**Stage 2: Document Writing**
1.  **Generate Framework Layer**: Create the initial `structs.json` based on the research topic, proposal, and processed references. If an exemplary reference paper exists, its structure can be emulated.
2.  **Generate Summary Layer**: Write detailed summaries for each framework node, forming `summaries.json`.
3.  **Write Body Layer**: Based on the framework structure and summary content, write detailed content for each part in the `./document_body/` directory, following the format `Chapter_X/Section_X.X_Title.md`. If a section becomes too long, split it into multiple files (e.g., `Section_X.X_Title_trunc_1.md`).

**Stage 3: Assembly & Synchronization**
1.  **Assemble Final Document**: Run a concatenation script that reads all Markdown files in `./document_body/` and merges them in the order defined by the framework layer into a complete `thesis_final.md` file. This is a programmatic process, not reliant on AI.
2.  **Critical: Synchronization Mechanism**:
    - **Top-down Modification**: When the user or AI modifies the **Framework Layer (`structs.json`)** or **Summary Layer (`summaries.json`)**, the corresponding **Body Layer** files must be rewritten or updated.
    - **Bottom-up Modification**: When the user or AI modifies a **Body Layer** file, extract its core information to update the corresponding **Summary Layer** entry and **Framework Layer** abstract.
    - This synchronization is crucial for maintaining logical consistency and preventing fragmentation, and must be executed after each modification.

## 4. How to Use (Operating Steps)
When the user triggers the skill, I will work according to the following logic:

1.  **Confirm Working Directory**: I will first establish the project root directory. If not specified, I will use the default `./PaperProject/` in the current working directory. All generated files will be placed within this directory or its subdirectories.
2.  **Execute the Requested Task**:
    - **If the request is "start" or "process references"**:
        a. Check the directory structure and list all items in the `references` folder.
        b. Execute the "Literature Review & Processing" workflow for each item.
        c. Generate a `literature_review_report.md` summarizing key findings and interconnections.
    - **If the request is "generate framework"**:
        a. Comprehensively analyze the research proposal, core insights from processed references, and institutional guidelines.
        b. Generate or update `structs.json` (Framework Layer) in the project root.
    - **If the request is "write body"**:
        a. Read `structs.json` and `summaries.json`.
        b. Create corresponding folders and files in the `./document_body/` directory and begin writing content. Existing files in this directory may be overwritten.
        c. While writing each section, query `summaries.json` and the associated reference knowledge bases.
    - **If the request is "sync modification"**:
        a. The user indicates which file was modified (e.g., `./document_body/Chapter_3/3.1_Current_Analysis.md`).
        b. I first read the modified file content, extract a new abstract and key points.
        c. Update the `section_summary` for the corresponding `section_id` in `summaries.json`.
        d. Update the `abstract` and `key_points` for the corresponding `section_id` in `structs.json`.
    - **If the request is "find literature"**:
        a. Perform a network search based on the user-provided keywords.
        b. Attempt to download PDFs to the `references` directory.
        c. Create a folder and `information.md` for each, regardless of download success. If downloaded successfully, proceed with structured parsing.
3.  **Output & Confirmation**: After each operation, I will clearly state which files were generated, their paths, and briefly describe their content.

## 5. Edge Cases
- **Directory Doesn't Exist**: If the project directory doesn't exist, I will ask the user if they want to create it.
- **References Folder Empty**: If the `references` folder is empty, I will notify the user and ask if they want to proceed directly to framework design or start a network search for literature.
- **Research Proposal Missing**: If no research proposal is found, I will generate a very basic initial framework based on the paper title and general academic structure, noting that it will require significant revision.
- **Sync Conflict**: If major, irreconcilable discrepancies are detected between the Framework, Summary, and Body layers for the same section, I will list the conflicts and **pause automatic synchronization**, requesting manual user judgment and instruction.