Response Tone Polisher

Response Tone Polisher

Polishes response letters to peer reviewers by softening harsh or defensive language while preserving the author's position and scientific integrity.

When to Use

Key Features

Dependencies

See ## Prerequisites above for related details.

Example Usage

cd "20260318/scientific-skills/Academic Writing/response-tone-polisher"
python -m py_compile scripts/main.py
python scripts/main.py --help

Example run plan: 1. Confirm the user input, output path, and any required config values. 2. Edit the in-file CONFIG block or documented parameters if the script uses fixed settings. 3. Run python scripts/main.py with the validated inputs. 4. Review the generated output and return the final artifact with any assumptions called out.

Implementation Details

See ## Overview above for related details.

Quick Check

Use this command to verify that the packaged script entry point can be parsed before deeper execution.

python -m py_compile scripts/main.py

Audit-Ready Commands

Use these concrete commands for validation. They are intentionally self-contained and avoid placeholder paths.

python -m py_compile scripts/main.py
python scripts/main.py --help

Overview

This skill analyzes author draft responses to reviewer comments and transforms confrontational or defensive phrasing into professional, diplomatic academic language. It helps researchers maintain positive relationships with reviewers while standing firm on scientifically justified positions.

Usage Examples

Basic Usage

Input:
Reviewer: The sample size is too small for meaningful conclusions.
Draft Response: I disagree. Our sample size is standard in this field.
Output:
We appreciate the reviewer's concern regarding sample size. While we acknowledge 
that larger samples provide greater statistical power, our sample size is consistent 
with established conventions in this field and meets the requirements for adequate 
power analysis (as detailed in the Methods section).

Defensive Language Transformation

| Original (Defensive) | Polished (Professional) | |---------------------|------------------------| | "I will not change this." | "We have carefully considered this suggestion and respectfully maintain our original approach because..." | | "The reviewer is wrong." | "We respectfully offer a different interpretation..." | | "This is unnecessary." | "We appreciate this suggestion; however, we believe the current presentation adequately addresses this point." | | "We already explained this." | "We have expanded our explanation to enhance clarity (Page X, Lines Y-Z)." | | "That's not our fault." | "We acknowledge this limitation and have added appropriate caveats to the Discussion." |

Input Parameters

| Parameter | Type | Required | Description | |-----------|------|----------|-------------| | reviewer_comment | str | Yes | The reviewer's original comment or criticism | | draft_response | str | Yes | Author's initial draft response (may contain harsh/defensive language) | | response_type | str | No | One of: accept, partial, decline (default: auto-detect) | | polish_level | str | No | light, moderate, heavy (default: moderate) | | preserve_meaning | bool | No | Ensure scientific position is preserved (default: true) |

Output Format

{
  "polished_response": "string",
  "original_tone_score": "float (0-1, higher = more defensive)",
  "improvements": [
    {
      "original_phrase": "string",
      "polished_phrase": "string",
      "issue_type": "string"
    }
  ],
  "suggestions": ["string"],
  "politeness_score": "float (0-1)"
}

Tone Patterns Detected

The skill identifies and transforms:

1. Direct Refusals

2. Defensive Statements

3. Blame Shifting

4. Emotional Language

Polite Academic Expressions

Acknowledging Reviewers

Expressing Disagreement Diplomatically

Explaining Limitations

Describing Changes

Workflow

1. Confirm the user objective, required inputs, and non-negotiable constraints before doing detailed work. 2. Validate that the request matches the documented scope and stop early if the task would require unsupported assumptions. 3. Use the packaged script path or the documented reasoning path with only the inputs that are actually available. 4. Return a structured result that separates assumptions, deliverables, risks, and unresolved items. 5. If execution fails or inputs are incomplete, switch to the fallback path and state exactly what blocked full completion.

Command Line Usage

Interactive mode
python scripts/main.py --interactive
File-based
python scripts/main.py \
  --reviewer-comment "comment.txt" \
  --draft-response "draft.txt" \
  --output "polished.txt"
Direct input
python scripts/main.py \
  --reviewer "The data is insufficient." \
  --draft "You are wrong. We have enough data." \
  --polish-level heavy

Python API

from scripts.main import TonePolisher
polisher = TonePolisher()
result = polisher.polish(
    reviewer_comment="The methodology is flawed.",
    draft_response="No it's not. We did it right.",
    response_type="decline",
    polish_level="moderate"
)
print(result["polished_response"])

References

Limitations

Quality Checklist

After polishing, verify:

Risk Assessment

| Risk Indicator | Assessment | Level | |----------------|------------|-------| | Code Execution | Python/R scripts executed locally | Medium | | Network Access | No external API calls | Low | | File System Access | Read input files, write output files | Medium | | Instruction Tampering | Standard prompt guidelines | Low | | Data Exposure | Output files saved to workspace | Low |

Security Checklist

Prerequisites

Python dependencies
pip install -r requirements.txt

Evaluation Criteria

Success Metrics

Test Cases

Lifecycle Status

Output Requirements

Every final response should make these items explicit when they are relevant:

Error Handling

Input Validation

This skill accepts requests that match the documented purpose of response-tone-polisher and include enough context to complete the workflow safely.

Do not continue the workflow when the request is out of scope, missing a critical input, or would require unsupported assumptions. Instead respond:

> response-tone-polisher only handles its documented workflow. Please provide the missing required inputs or switch to a more suitable skill.

Response Template

Use the following fixed structure for non-trivial requests:

1. Objective 2. Inputs Received 3. Assumptions 4. Workflow 5. Deliverable 6. Risks and Limits 7. Next Checks

If the request is simple, you may compress the structure, but still keep assumptions and limits explicit when they affect correctness.

Python dependencies
pip install -r requirements.txt