Skip to content

PROMOTION.md

Latest commit

 

History

History
395 lines (284 loc) · 11 KB

PROMOTION.md

File metadata and controls

395 lines (284 loc) · 11 KB

Promotion & Discoverability Guide

Purpose: Actionable steps to maximize visibility for the Rust Tutor Claude Plugin Status: Ready to execute after publishing to GitHub

GitHub Repository Setup

Topics to Add

When you push to GitHub, add these topics to maximize discoverability:

Priority Topics (add these first):

  • rust
  • claude-code
  • claude-plugin
  • learning
  • tdd
  • education

Secondary Topics (add if under the 20-topic limit):

  • rust-learning
  • test-driven-development
  • progressive-learning
  • clippy
  • rustfmt
  • quality-gates
  • developer-tools
  • coding-education

How to add topics on GitHub:

  1. Go to your repo: https://github.com/razlani/rust-tutor-claude-plugin
  2. Click the gear icon ⚙️ next to "About"
  3. Add topics in the "Topics" field
  4. Save changes

Repository Description

Use this as your GitHub repo description (max 350 chars):

Interactive Rust learning plugin for Claude Code with progression levels, quality gates, and an auto-mode that challenges you to implement real functions while building projects. Learn by doing, not watching.

Repository Settings

  • ✅ Enable Issues (for user feedback)
  • ✅ Enable Discussions (for community Q&A)
  • ✅ Disable Wiki (unless you plan to use it)
  • ✅ Add website: https://github.com/razlani/rust-tutor-claude-plugin
  • ✅ Add topics (see list above)

Social Media Promotion

Reddit

Recommended Subreddits (in order of priority):

1. r/rust

When to post: After you have 2-3 users who've tested it successfully Title suggestion:

[Plugin] Interactive Rust Tutor for Claude Code - Learn by implementing, not watching

Post template:

I built an interactive Rust learning plugin for Claude Code that teaches through progressive challenges and strict quality gates.

**How it works:**
- You get a failing test and function stub
- You implement the function
- Claude enforces fmt, clippy, tests, and no-unwrap policies
- Build a 3-task streak to level up through 5 progressive levels

**Key features:**
- Auto-mode: Learn while building real projects (Claude pauses and challenges you before writing Rust code)
- Quality gates: Every slice must pass formatting, lints, tests, and policy checks
- Progress tracking: Levels, streaks, and learning history

GitHub: https://github.com/razlani/rust-tutor-claude-plugin

Looking for feedback from the community! What concepts would you want in a Level 6?

Timing: Post on a weekday morning (Tuesday-Thursday, 8-10am US Eastern) for best visibility

2. r/ClaudeAI

Title suggestion:

I built a Rust learning plugin for Claude Code with auto-mode challenges

Post template:

I created a Claude Code plugin that turns learning Rust into an interactive challenge system.

**What makes it different:**
- Claude challenges you to implement actual code for your project
- Strict quality gates (fmt + clippy + tests + no unwrap policy)
- 5 progressive levels from basics to CLI development
- Auto-mode: Learn while building - Claude pauses before writing Rust and asks you to implement it

**Example workflow:**
1. `/slice` - Get a challenge with failing test
2. Implement the function
3. `/gate` - Validate with quality checks
4. Pass 3 in a row → level up!

It uses hooks to inject learning context automatically, so Claude knows when to challenge you without you asking.

GitHub: https://github.com/razlani/rust-tutor-claude-plugin

Feedback welcome!

Timing: Post on weekends for r/ClaudeAI (higher weekend activity)

3. r/learnrust

Title suggestion:

Claude Code plugin for test-driven Rust learning

Post template (shorter, education-focused):

Built a Claude Code plugin for hands-on Rust learning:

- Failing-test-first methodology
- 5 progressive difficulty levels
- Quality gates: fmt, clippy, tests, no-unwrap policy
- Auto-mode for learning while building real projects

You implement the code, Claude enforces quality and guides you.

GitHub: https://github.com/razlani/rust-tutor-claude-plugin

Free, MIT licensed. Looking for learners to test it!

Twitter/X

Tweet suggestions (thread format):

Tweet 1 (hook):

I built a Claude Code plugin that stops Claude from writing Rust for you

Instead, it challenges you to implement functions yourself with strict quality gates

Here's how it works 🧵

Tweet 2 (demo):

1. Run /slice → Get a failing test + stub
2. You implement the function
3. Run /gate → Claude checks fmt, clippy, tests, policy
4. Pass 3 in a row → level up

5 levels: basics → CLI development

Tweet 3 (unique feature):

The coolest part: AUTO-MODE

Enable it, then build a project normally

Claude will pause before writing Rust and challenge you to implement the ACTUAL code you need

Learn by doing, not watching

Tweet 4 (CTA):

Free & open source (MIT)

GitHub: https://github.com/razlani/rust-tutor-claude-plugin

Looking for feedback from Rust learners!

Hashtags: #Rust #RustLang #ClaudeAI #LearnToCode #TDD

Best time to post: Weekday mornings 9-11am US Eastern

Hacker News (Show HN)

When to post: After you have some GitHub stars and positive Reddit feedback

Title:

Show HN: Interactive Rust learning plugin for Claude Code with quality gates

Comment (post this immediately after submitting):

Author here. I built this because most coding tutorials show you the code instead of making you write it.

This plugin flips that: Claude gives you a failing test and enforces strict quality gates (fmt, clippy, tests, no unwrap in libs). You have to implement the code yourself.

The auto-mode is the interesting part technically - it uses a UserPromptSubmit hook to inject learning context into every user message, so Claude naturally knows when to challenge you without you asking. Before writing Rust functions, Claude checks if they match your skill level and pauses to let you implement them.

5 progressive levels from basics to CLI development. Open source (MIT), works with Claude Code.

Happy to answer questions about the implementation or approach!

Best time: Tuesday-Thursday, 8-9am US Eastern

Dev.to

Article title:

Building an Interactive Rust Tutor Plugin for Claude Code

Article topics to cover:

  1. Why passive learning doesn't work for coding
  2. The failing-test-first methodology
  3. How hooks work in Claude Code plugins
  4. Auto-mode implementation (technical deep dive)
  5. Quality gates and why strictness helps learning
  6. Lessons learned building the plugin

CTA: Link to GitHub, ask for feedback and contributions

LinkedIn

Post suggestion (professional tone):

🎓 Built an interactive learning system for Rust using Claude Code

Instead of watching code being written, learners:
- Get a failing test and function stub
- Implement the solution themselves
- Pass quality gates (formatting, linting, tests, policies)
- Progress through 5 levels of increasing difficulty

The "auto-mode" feature integrates learning into real project work - Claude pauses before writing Rust code and challenges developers to implement it themselves.

Open source and free: https://github.com/razlani/rust-tutor-claude-plugin

#SoftwareEngineering #Learning #Rust #AI

Community Engagement

When Issues/Discussions Start

Good first responses (set the tone):

  • Thank contributors quickly (within 24 hours)
  • Be open to feedback and suggestions
  • Document common questions in FAQ
  • Credit contributors in CHANGELOG

Common questions to prepare for:

  1. "Does this work with workspaces?" → Yes, tested with both
  2. "Can I customize levels?" → Yes, edit .claude/tutor/levels.yaml
  3. "What if I get stuck?" → Ask Claude for hints (don't ask for full solution)
  4. "Why so strict?" → Strictness builds better habits; you can customize

Building a Community

Consider creating:

  • Discord server (if you get 50+ stars)
  • Weekly "learning challenge" (share on Reddit/Twitter)
  • Contributor guide
  • Video walkthrough (YouTube/Loom)

Don't over-commit:

  • Start with Issues only
  • Add Discussions if Issues get chatty
  • Only add Discord if community demands it
  • Keep scope focused (resist feature creep)

Metrics to Track

GitHub:

  • Stars (target: 100 in first month)
  • Forks (indicates people are customizing)
  • Issues (healthy: 5-10 open, mostly features)
  • Traffic (views, clones, referrers)

Reddit:

  • Upvotes (good post: 50+ on r/rust)
  • Comments (aim for discussion, not just praise)
  • Crossposts (indicates spread)

Twitter:

  • Likes, retweets (less important than GitHub stars)
  • Clicks to GitHub

Conversion:

  • GitHub stars per Reddit upvote (target: ~0.5)
  • Issues per 100 stars (healthy: 5-10)

Timeline Recommendation

Week 1: Soft Launch

  • ✅ Push to GitHub
  • ✅ Add topics and description
  • ✅ Test installation from GitHub (confirm it works)
  • ✅ Post to r/ClaudeAI (smaller, friendlier audience)
  • ✅ Share on Twitter (build initial awareness)

Week 2: Iterate

  • ✅ Fix any issues from early adopters
  • ✅ Add FAQ to README based on questions
  • ✅ Improve documentation if needed

Week 3: Main Launch

  • ✅ Post to r/rust (bigger audience, higher bar)
  • ✅ Post to r/learnrust
  • ✅ Submit to Hacker News (Show HN)

Week 4: Content

  • ✅ Write Dev.to article
  • ✅ Post walkthrough video (if applicable)
  • ✅ Share results and learnings

Quick Wins

Do these NOW (5 minutes each):

  1. Add topics to GitHub repo
  2. Set repo description
  3. Enable Issues and Discussions
  4. Draft first Reddit post (don't publish yet - wait until you test install from GitHub)

Do these AFTER first GitHub push:

  1. Test installation: git clone, then /plugin install
  2. Fix any installation issues
  3. Get 1-2 friends to test it
  4. Post to r/ClaudeAI

Do these WEEK 2+:

  1. Address early feedback
  2. Post to r/rust and r/learnrust
  3. Submit to Hacker News
  4. Write long-form content

What NOT to Do

❌ Don't spam - One post per subreddit, max 1-2 per day across platforms ❌ Don't over-promise - Be honest about current state and limitations ❌ Don't argue with critics - Acknowledge feedback, iterate ❌ Don't ignore issues - Even if you can't fix immediately, acknowledge them ❌ Don't forget to test - Make sure installation works before promoting widely

Success Indicators

Early (Week 1-2):

  • 10+ stars on GitHub
  • 2-3 Issues or Discussions opened
  • Positive comments on Reddit post

Medium (Week 3-4):

  • 50+ stars on GitHub
  • 5+ Issues (mix of bugs and features)
  • Mentions on Twitter or other blogs

Long-term (Month 2-3):

  • 100+ stars
  • Active community (Issues, PRs, Discussions)
  • Organically mentioned in "awesome Rust" or "Claude Code plugins" lists

Next Steps

  1. Immediate: Push to GitHub, add topics
  2. Day 1: Test installation from GitHub
  3. Day 2-3: Soft launch on r/ClaudeAI and Twitter
  4. Week 2: Address feedback, improve docs
  5. Week 3: Main launch on r/rust and Show HN

Questions or need help? Feel free to adjust this plan based on your goals and availability!