MacroKeys - VS Code Macro Recorder With Playback Library
VS Code is the most popular editor on Earth and it still cannot record keystrokes like Notepad++ from 2003. MacroKeys fills the embarrassing gap with a dead-simple record-replay extension plus a shareable macro library for teams.
Difficulty
intermediate
Category
Developer Tools
Market Demand
Very High
Revenue Score
8/10
Platform
VS Code Extension
Vibe Code Friendly
No
Hackathon Score
🏆 7/10
Validated by Real Pain
— seeded from real developer complaints
A long-running VS Code GitHub issue with hundreds of thumbs-up requests users complaining that the editor has no built-in macro recording and they are forced to switch to Vim or Notepad++ just for this feature.
What is it?
Every developer who has spent 20 minutes manually reformatting 400 JSON lines knows the pain: VS Code has no native macro recording. Vim users cope with q-registers, Notepad++ users defect, and everyone else writes a one-off regex that breaks on line three. MacroKeys lets you hit Cmd+Shift+R to start recording, hit it again to stop, then replay instantly. Macros are saved as readable JSON you can name, edit, and share. A premium tier unlocks conditional macros, folder-level macro sets, and a public library where teams publish reusable workflows. Buildable as a VS Code extension in a weekend using the VS Code Extension API, zero external backend needed for the free tier.
Why now?
VS Code hit 73% market share per Stack Overflow 2025 survey and still ships zero macro recording — the April 2026 vibe-coding wave means more non-Vim developers are in VS Code daily and feeling this pain acutely.
- ▸One-shortcut record and replay with visual recording indicator in status bar
- ▸Macro saved as human-readable JSON with rename and edit support
- ▸Conditional macros that branch on selected text content (premium)
- ▸Public macro library with search and one-click import (premium)
Target Audience
VS Code users — estimated 73% of all developers per Stack Overflow 2024 survey, roughly 20M active installs base.
Example Use Case
A backend dev recording a macro to wrap every selected variable in console.log, replay it 40 times in 3 seconds, and share it to the team library so nobody types it again.
User Stories
- ▸As a backend developer, I want to record a repetitive text transformation and replay it 50 times, so that I save 20 minutes of manual editing.
- ▸As a team lead, I want to share a macro with my team via a library link, so that everyone uses the same formatting shortcut.
- ▸As a power user, I want to edit the raw JSON of my macro, so that I can fine-tune the exact keystrokes without re-recording.
Acceptance Criteria
Record: done when Cmd+Shift+R starts recording and status bar shows RECORDING indicator. Replay: done when saved macro reproduces identical text changes on replay without errors. Storage: done when macros persist after VS Code restart. Premium gate: done when conditional macro feature is locked behind Stripe-verified subscription.
Is it worth building?
$5/month x 500 paid users = $2,500 MRR. Realistic at month 4 given VS Code Marketplace organic discovery. $39 lifetime converts ~30% of paid intent.
Unit Economics
CAC: $0 via Marketplace organic. LTV: $60 (12 months at $5/month). Payback: immediate. Gross margin: 97%.
Business Model
Freemium, $5/month premium or $39 lifetime
Monetization Path
Free tier covers basic record/replay. Upgrade wall hits at conditional macros and team library sync.
Revenue Timeline
First dollar: week 3 via first premium upgrade. $1k MRR: month 4. $5k MRR: month 12 with team plans.
Estimated Monthly Cost
Supabase free tier: $0, Vercel for library API: $0 (hobby), Stripe fees on $2k MRR: ~$60. Total: ~$60/month.
Profit Potential
Side income at $1k MRR, full-time viable at $8k MRR with team plans.
Scalability
High — marketplace distribution is free, team plan adds $15/seat/month tier.
Success Metrics
Week 1: 500 Marketplace installs. Month 1: 50 premium upgrades. Month 3: 4.5+ star rating with 200 reviews.
Launch & Validation Plan
Post in r/vscode asking if macro recording is wanted, collect 50 upvotes as green light, then ship beta to 10 volunteers before Marketplace publish.
Customer Acquisition Strategy
First install: post a 30-second screen recording of the macro replay on r/vscode and r/programming — no pitch, just the demo. Ongoing: VS Code Marketplace organic, ProductHunt launch, Dev.to tutorial article targeting VS Code macro search queries.
What's the competition?
Competition Level
Low
Similar Products
macro-commander VS Code extension (unmaintained since 2021), Vim (different editor), Notepad++ macros (different editor) — none offer in-VS Code record plus cloud library.
Competitive Advantage
Only macro recorder natively in VS Code with a shareable library — Vim and Notepad++ require leaving the editor.
Regulatory Risks
Low regulatory risk.
What's the roadmap?
Feature Roadmap
V1 (launch): record, replay, rename, JSON edit. V2 (month 2-3): conditional macros, cloud sync. V3 (month 4+): public library, team plans.
Milestone Plan
Phase 1 (Week 1-2): record/replay working locally, Marketplace published. Phase 2 (Week 3-4): cloud sync and Stripe premium gate live. Phase 3 (Month 2): public library with search and install count.
How do you build it?
Tech Stack
VS Code Extension API, TypeScript, Node.js, Supabase for macro library sync — build with Cursor for logic, v0 for settings UI webview
Suggested Frameworks
VS Code Extension API, TypeScript, Supabase JS SDK
Time to Ship
2 weeks
Required Skills
TypeScript, VS Code Extension API, basic Supabase.
Resources
VS Code Extension API docs, vscode-extension-samples on GitHub, Supabase quickstart.
MVP Scope
extension/src/extension.ts (activate command), macroRecorder.ts (keystroke capture), macroPlayer.ts (replay engine), macroStorage.ts (JSON read/write), statusBar.ts (recording indicator), webview/settings.html (macro list UI), package.json (commands manifest), README.md.
Core User Journey
Install extension -> hit Cmd+Shift+R to record -> perform keystrokes -> hit Cmd+Shift+R to stop -> hit Cmd+Shift+P to replay -> upgrade for team library.
Architecture Pattern
Keypress events -> macroRecorder buffer -> JSON file in workspace storage -> macroPlayer replays via VS Code API -> optional Supabase sync for library.
Data Model
User has many Macros. Macro has name, steps array, isPublic flag, tags. LibraryMacro is a published copy with author and install count.
Integration Points
VS Code Extension API for keystroke capture, Supabase for macro library sync, Stripe for premium billing via web portal.
V1 Scope Boundaries
V1 excludes: multi-cursor macro support, cross-editor sync, IDE plugins for JetBrains, and team billing.
Success Definition
A developer finds MacroKeys on the Marketplace without a referral, upgrades to premium, and shares a macro to the public library within their first week.
Challenges
VS Code Marketplace SEO and reviews dominate discovery — getting the first 100 installs without a launch spike is the real challenge, not the code.
Avoid These Pitfalls
Do not try to capture every VS Code command — focus on text edits only or you will chase edge cases for months. Do not launch without a demo GIF in the Marketplace readme. Do not price monthly-only — lifetime option converts impulse buyers.
Security Requirements
Supabase Auth with GitHub OAuth for library sync. RLS on all macro rows. Input validation on macro name and tags fields. No keystroke data sent to server — all processing is local.
Infrastructure Plan
Extension runs 100% locally. Supabase free tier for library. Vercel hobby plan for premium auth webhook. Sentry for error tracking via VS Code telemetry.
Performance Targets
Replay must execute under 50ms per step. Extension activation under 200ms. Library search API under 300ms. No impact on VS Code startup time.
Go-Live Checklist
- ☐Security audit complete
- ☐Payment flow tested end-to-end
- ☐Error tracking live
- ☐Monitoring dashboard configured
- ☐Custom domain set up
- ☐Privacy policy published
- ☐5 beta users signed off
- ☐Rollback plan documented
- ☐Launch post drafted for r/vscode and ProductHunt.
How to build it, step by step
1. Run yo code to scaffold a new VS Code extension in TypeScript. 2. Register recordMacro and replayMacro commands in package.json contributes. 3. Implement keystroke listener using vscode.workspace.onDidChangeTextDocument. 4. Store recorded steps as JSON array in ExtensionContext globalState. 5. Implement replay by iterating steps and calling vscode.commands.executeCommand. 6. Add status bar item that shows RECORDING in red when active. 7. Build a webview panel listing saved macros with rename and delete. 8. Add Supabase client for optional cloud sync behind a sign-in gate. 9. Set up Stripe payment link for premium upgrade redirecting from the webview. 10. Publish to VS Code Marketplace and post demo on r/vscode.
Generated
April 10, 2026
Model
claude-sonnet-4-6