Quick Fixes: How ProseLint Web Helps You Fix Writing Issues Instantly
Reading a linting report is helpful. Applying the fixes is where the real work happens. Traditional linters identify problems and leave you to manually search, edit, and correct each issue. For a document with dozens of style violations, this manual fix process takes longer than the original writing.
ProseLint Web's quick-fix system automates corrections. When Vale identifies a style issue, it often provides a one-click fix that applies the correction automatically. No copying suggestions, no manual find-and-replace, no context switching between linter output and editor—just click and fix.
This automation transforms linting from a review process into an improvement tool that actually improves your writing faster.
The manual fixing problem
Without automated fixes, linting creates work instead of saving time:
Context switching slows you down
Traditional linting workflow:
- Run linter and read issue list
- Find the issue location in your editor by line number
- Read the suggestion in the linter output
- Switch to editor and locate the exact text
- Manually type the fix or copy the suggestion
- Verify the fix didn't introduce typos
- Repeat for every issue
This constant switching between linting output and editor wastes cognitive energy and time.
Copy-paste introduces errors
Manually copying suggested fixes creates risks:
Typos in suggestions: Typing out suggestions introduces new errors Incomplete copies: Partial selections miss important characters Formatting loss: Copy-paste can lose formatting, whitespace, or punctuation Regression testing: Every manual fix requires re-linting to verify it worked
High issue counts discourage fixing
When a document has 50+ style issues:
Fixing feels overwhelming: The manual work required discourages addressing all issues Writers cherry-pick: Only obvious or critical errors get fixed, leaving inconsistency Quality suffers: Partial fixing doesn't achieve style guide compliance Time pressure wins: Deadlines mean many issues never get addressed
Automated fixes solve all these problems by making corrections instant and error-free.
Vale's quick-fix action system
Vale includes an action system that defines automated corrections for rules:
Four action types
Vale rules can specify actions that tools like ProseLint Web can execute:
Replace: Simple text replacement—substitute the matched text with a specific alternative
Issue: "Utilize the API"
Rule: Prefer "use" over "utilize"
Action: Replace "Utilize" with "Use"
Result: "Use the API"
Edit: Pattern-based transformation using regular expressions—add, remove, or rearrange text
Issue: "Click on the button"
Rule: Remove unnecessary "on" after "click"
Action: Edit to remove " on"
Result: "Click the button"
Remove: Delete the matched text entirely—for redundant words or unnecessary phrases
Issue: "Very unique solution"
Rule: "Very" is redundant with "unique"
Action: Remove "Very "
Result: "Unique solution"
Suggest: Provide multiple alternatives for context-dependent issues
Issue: "Whitelist the domain"
Rule: Use inclusive language
Action: Suggest "allowlist" or "approved list"
Result: Writer chooses appropriate alternative
How quick fixes work in ProseLint Web
When you lint content in ProseLint Web:
- Vale identifies issues and checks if the rule includes actions
- Issues with actions display "Quick Fix" buttons in the issues panel
- Click the button to apply the fix instantly
- Editor updates automatically with the correction applied
- Issue disappears from the issues list (or updates if partially resolved)
- Re-lint to verify or continue fixing other issues
The entire process takes one click per issue—no manual editing required.
Examples of quick-fix automation
Here are real-world examples of quick fixes in action:
Example 1: Passive voice correction
Original text:
The configuration file is read by the application at startup.
Vale identifies:
- Rule: Microsoft.Passive (avoid passive voice)
- Issue: "is read by" detected at line 1
- Quick fix available: Convert to active voice
One-click result:
The application reads the configuration file at startup.
Manual equivalent: Find the passive construction, identify the actor ("the application"), restructure the sentence to make it the subject, adjust verb form. Time: 30-60 seconds per instance.
Quick fix time: 1 second.
Example 2: Terminology consistency
Original text:
Use the commandline to execute the script.
Vale identifies:
- Rule: Microsoft.Terms (enforce specific terminology)
- Issue: "commandline" should be "command line" (two words)
- Quick fix available: Replace with correct term
One-click result:
Use the command line to execute the script.
Impact: Consistency across all documentation—Vale catches every instance and fixes it uniformly.
Example 3: Removing redundant phrases
Original text:
In order to install the package, first download the installer.
Vale identifies:
- Rule: Vale.Redundancy (avoid wordy constructions)
- Issue: "In order to" is redundant—"To" suffices
- Quick fix available: Remove redundant phrase
One-click result:
To install the package, first download the installer.
Effect: Tighter, clearer writing with less effort than manual editing.
Example 4: Inclusive language updates
Original text:
The master server replicates data to slave servers.
Vale identifies:
- Rule: RedHat.InclusiveLanguage (use inclusive terminology)
- Issue: "master/slave" terminology flagged
- Quick fix available: Replace with inclusive alternatives
One-click result:
The primary server replicates data to replica servers.
Cultural impact: Modernize documentation to use respectful, inclusive language effortlessly.
Example 5: Hedging and weak language
Original text:
This feature might possibly help improve performance.
Vale identifies:
- Rule: Microsoft.Hedging (avoid uncertain language)
- Issues: Both "might" and "possibly" are hedging words
- Quick fixes available: Remove hedge words
After two clicks:
This feature improves performance.
Result: Confident, direct writing that serves users better.
Advanced quick-fix capabilities
Vale's action system handles complex transformations:
Regex-based edits
Edit actions support regular expressions for sophisticated changes:
Pattern matching: Identify complex structures and transform them Capture groups: Preserve parts of the original while changing others Contextual replacement: Different fixes based on surrounding text
Example:
Original: "Please refer to the documentation"
Rule: Simplify "refer to" to "see"
Edit pattern: Replace "refer to" with "see"
Result: "Please see the documentation"
Multi-word corrections
Quick fixes handle phrase-level issues:
Compound term corrections: "Email" vs. "e-mail" vs. "E-mail" Phrase simplification: "At this point in time" → "now" Idiomatic improvements: "Take into consideration" → "consider"
Case-aware replacements
Quick fixes respect capitalization context:
"Utilize" → "Use" (sentence start)
"utilize" → "use" (mid-sentence)
"UTILIZE" → "USE" (all caps contexts)
Vale's replacement actions adjust case appropriately.
Batch fixing workflows
While each fix is one click, you can work through issues efficiently:
- Sort issues by rule: Fix all instances of one rule type together
- Filter by severity: Address errors first, then warnings, then suggestions
- Work through sequentially: Click through the list, applying fixes in order
- Re-lint after batch: Verify all corrections applied successfully
When to use quick fixes vs. manual editing
Quick fixes aren't always the right choice:
Use quick fixes for:
Objective style rules: Terminology standards, passive voice detection, redundancy removal—rules with clear, correct applications
High-volume issues: When a document has many instances of the same issue, quick fixes save enormous time
Consistency enforcement: Applying the same fix across all instances ensures uniform style
Learning opportunities: Quick fixes show you what correct writing looks like, training you to avoid issues in future drafts
Manual review recommended for:
Context-dependent suggestions: Some passive voice is appropriate (focusing on the action rather than actor). Review before fixing.
Tone and voice decisions: Suggestions about formality, hedging, or emphasis may depend on audience and purpose
Technical accuracy: Ensure quick fixes don't change technical meaning. "The process runs asynchronously" might trigger simplification rules, but "runs asynchronously" is technically precise.
Creative or marketing content: Style guides for technical docs may not apply to creative writing, taglines, or marketing copy
Always re-lint after applying fixes to catch any new issues introduced.
Comparing quick-fix capabilities
Different tools offer varying levels of fix automation:
Commercial grammar checkers
Grammarly, ProWritingAid: Provide automated suggestions with "Accept" buttons for individual changes. Limited to generic grammar and style rules—no custom style guide actions.
Limitation: Can't enforce organization-specific terminology or industry style guides automatically.
Vale CLI
Quick fix support: Vale CLI identifies issues and includes action data in output, but applying fixes requires integration with editors or custom scripting.
VS Code extension: The Vale VS Code extension provides code actions (lightbulb menu) that apply Vale's quick fixes within the editor.
CI/CD: Automated fixes in CI require custom tooling to parse Vale output and apply changes.
ProseLint Web
Browser-based quick fixes: One-click application of all Vale action types (replace, edit, remove, suggest) directly in the browser editor.
Immediate feedback: Click fix, see result instantly, no context switching.
No installation: Quick fixes work immediately without editor integration or local setup.
Building quick-fix workflows
Integrate automated fixes into your documentation process:
For individual writers
- Lint before final review: Run ProseLint Web on completed drafts
- Apply obvious fixes first: Use quick fixes for clear issues (terminology, redundancy)
- Review contextual suggestions: Manually evaluate passive voice and hedging fixes
- Re-lint to verify: Confirm fixes resolved issues and didn't introduce new ones
- Commit polished content: Submit documentation with confidence
For documentation teams
- Standardize on style guide: Choose Microsoft, Google, Red Hat, or custom package
- Document fix policies: Clarify which rules should auto-fix vs. require review
- Train on quick fixes: Show team members how to use automated fixes efficiently
- Integrate with CI: Use Vale CLI in CI to catch issues, ProseLint Web for fixing
- Measure improvement: Track reduction in linting issues over time as team internalizes rules
For open-source projects
- Link ProseLint Web in CONTRIBUTING.md: Make quick fixes accessible to all contributors
- List auto-fixable rules: Tell contributors which issues they can fix with one click
- Reduce maintainer burden: Contributors submit cleaner PRs, reducing editorial work
- Encourage self-review: Quick fixes empower contributors to polish their own work
Future quick-fix enhancements
Upcoming improvements may include:
Batch quick fixes: Apply all fixes of a certain type (e.g., "fix all terminology") with one action
Smart suggestions: AI-enhanced context analysis for better automatic fix proposals
Custom actions: Define organization-specific quick fixes for internal style rules
Fix previews: See the proposed change highlighted before applying
Undo/redo: Easily revert quick fixes if they produce unintended results
Conclusion: automation makes quality accessible
Linting identifies problems. Quick fixes solve them. This distinction matters enormously for practical workflow impact.
Without automated fixes, linting creates a to-do list that requires manual, time-consuming work to address. Writers see the issues but lack time to fix them all, leading to partial compliance and inconsistent quality.
With quick fixes, linting becomes an improvement tool that actively makes your writing better—in seconds, with one click per issue. The time savings and error reduction make comprehensive style guide compliance practical for every document, not just high-priority releases.
Try ProseLint Web's quick fixes on your next document and experience the difference between knowing what's wrong and actually fixing it instantly.
Resources
- ProseLint Web editor — one-click quick fixes for style issues
- Vale CLI — command-line linting with action support
- Vale VS Code extension — quick fixes in VS Code
- Vale action system documentation — how Vale defines automated fixes
Ready to try ProseLint Web?
Experience privacy-first documentation linting in your browser. No installation required.