DEV Community: Elizabeth Stein

My Bartending Job Taught Me More About Software Than School Did

Elizabeth Stein — Fri, 06 Mar 2026 03:25:40 +0000

I've been bartending since 2013. I graduate with my software development degree in three weeks.

The verdict: The bar taught me more useful skills than most of my classes.

I'm not saying school was useless. I learned algorithms, data structures, SQL optimization, and all that stuff matters.

But the skills that actually help me build things, ship projects, and work with people? Those came from dealing with drunk people at 11 PM on a Saturday.

Here's what I mean.

1. User Experience Is Everything

At the bar:
If someone can't figure out how to order from you in 10 seconds, they go somewhere else. You learn to read people instantly. What do they want? What's confusing them? How do I make this easier?

In software:
If your user can't figure out your app in 10 seconds, they close the tab. Same energy. Same urgency.

School taught me how to build a database. The bar taught me why nobody cares about your database if they can't find the damn submit button.

UX isn't a nice-to-have. It's the whole point.

2. Handle Production Issues in Real Time

At the bar:
The POS system crashes during Friday rush. The blender breaks mid-margarita. Someone spills a full tray. You don't get to "push a hotfix tomorrow." You fix it now while 30 people are staring at you.

In software:
Production goes down. Users are waiting. No one cares that you're scared or don't know the answer yet. You troubleshoot under pressure, ask for help when stuck, and ship the fix.

School gave me practice problems with perfect conditions.

The bar gave me chaos management.

That's the real skill.

3. Communication > Technical Perfection

At the bar:
You can make the most technically perfect cocktail in the world. If you're rude, slow, or confusing, no one cares. They leave. They don't tip. They tell their friends you suck.

The bartender who's decent at drinks but great with people? Packed every shift.

In software:
You can write the cleanest code in the world. If you can't explain your decisions, can't collaborate, or make everything harder for your team, no one wants to work with you.

I've seen brilliant developers get passed over for promotion because they couldn't communicate.

I've seen average developers lead teams because they could explain things clearly and make people feel heard.

School never taught me that. The bar beat it into me every single shift.

4. Scope Creep Is Real (and You Have to Say No)

At the bar:
"Can you make me something fruity but not sweet, strong but not too strong, with vodka but also tequila, and make it look cool?"

If you say yes to everything, you'll spend 10 minutes on one drink while six other people walk out.

You learn to manage expectations and set boundaries fast.

In software:
"Can we add login, payments, analytics, dark mode, mobile app, and AI chatbot to this MVP all in three weeks?"

If you say yes to everything, you'll ship nothing.

Bartending taught me that saying no is a skill, not a weakness.

You don't ignore the customer. You guide them to something achievable. Same with clients and stakeholders.

5. You Learn More By Doing Than By Studying

At the bar:
No amount of training videos prepares you for a Saturday night rush. You learn by getting destroyed on your first weekend, making mistakes, and figuring it out.

In software:
No amount of tutorials prepares you for building a real project. You learn by breaking things, Googling errors at 2 AM, and shipping messy v1s.

School gave me theory. The bar gave me reps.

And reps are what actually make you good.

6. People Don't Care How Hard It Was

At the bar:
No one cares that the ice machine is broken or that you're short-staffed. They want their drink. Now.

In software:
No one cares that the API docs were terrible or that your teammate quit mid-sprint. They want the feature. Working.

You learn to stop making excuses and start solving problems.

Bartending beat the victim mentality out of me fast.

What This Actually Means

I'm not saying everyone should bartend before they code (though honestly, it wouldn't hurt).

I'm saying the soft skills matter more than we admit.

And most of them don't come from a classroom. They come from high-pressure environments where you have to:

Read people quickly
Communicate clearly
Fix things under stress
Say no when necessary
Ship results, not excuses

If you're switching careers into tech, don't downplay your "non-technical" experience.

That bartending job? That retail grind? That customer service hell?

Those taught you things a bootcamp can't.

They taught you how to handle pressure, work with people, and get things done when everything is on fire.

That's not a side skill. That's the whole game.

My Advice If You're Career Switching

Don't hide your past work. Use it.

When you're in interviews, don't say:
❌ "I used to bartend but now I'm a developer"

Say:
✅ "I spent 7 years managing high-pressure customer interactions in real time. Now I build software that solves real user problems under tight deadlines."

Same background. Different framing. Way more powerful.

Your "unrelated" job taught you things that a lot of junior devs don't have yet:

How to stay calm under pressure
How to communicate with non-technical people
How to manage scope and expectations
How to ship when things aren't perfect

That's not a weakness. That's your edge.

What "unrelated" job taught you the most about tech?

I built HireReady: AI voice interviews + spaced repetition for tech interview prep

Elizabeth Stein — Thu, 05 Mar 2026 20:15:40 +0000

Hey DEV community! I just launched HireReady and wanted to share it with you.

What is it?

HireReady is a technical interview preparation platform that combines two things I think are underused in interview prep:

AI-powered voice interviews using OpenAI's Realtime API — so you can actually practice speaking your answers out loud, not just typing them
Spaced repetition (FSRS-5 algorithm) — so the app automatically schedules reviews of questions you're weakest on

The problem

I was frustrated with existing interview prep tools. Most of them are just question banks where you grind through problems with no structure. You forget what you studied last week, and you never practice actually talking through your answers — which is what the real interview is.

What it does

1,300+ questions across coding, system design, and behavioral categories
AI voice interviews — talk through problems like a real interview, get real-time feedback
Adaptive difficulty using Item Response Theory (IRT) parameters
Spaced repetition scheduling via ts-fsrs so you review at optimal intervals
STAR method story bank for behavioral questions
Gamification — XP, streaks, leaderboards, and mastery badges to keep you consistent
Study plans — AI-generated personalized plans based on your target role and timeline

Tech stack

Next.js 16 + React 19 (App Router)
TypeScript, Tailwind CSS 4, shadcn/ui
Supabase (Postgres + Auth + RLS)
Stripe for subscriptions
OpenAI Realtime API for voice
ts-fsrs for spaced repetition
Deployed on Vercel

Try it out

The free tier gives you access to practice questions with spaced repetition. Pro unlocks voice interviews, advanced analytics, and unlimited practice.

Check it out at imhireready.com

I'd love to hear your feedback — what features would be most useful for your interview prep? Drop a comment below!

How I Built an AI Documentation Engine with Tree-sitter, Claude AI, and RAG

Elizabeth Stein — Tue, 03 Mar 2026 15:27:45 +0000

Documentation is every developer’s least favorite task.

We all agree it’s important. We all intend to keep it updated. And yet… it’s usually the first thing to fall behind.

After watching this happen on every team I’ve worked with, I built AutomaDocs — an AI-powered documentation engine that connects to your GitHub repos and keeps docs in sync automatically.

Here’s how the system works and what I learned building it.

The Real Problem

Every engineering team has had this conversation:

PM: “Are the docs updated?”
Dev: “Uh… mostly.”
PM: “The API endpoint changed last week.”
Dev: “…I’ll update them tomorrow.”

The issue isn’t laziness. It’s architecture.

We treat documentation as a separate artifact from the code — but the code changes constantly. Keeping two parallel systems in sync manually doesn’t scale.

So I asked:

What if documentation wasn’t written manually at all?

What if it was generated directly from structured code understanding?

That became AutomaDocs.

The Architecture

AutomaDocs has three core layers:

Structured code analysis
LLM-powered documentation generation
Continuous sync + retrieval (RAG)

Let’s break it down.

1. Code Analysis with :contentReference[oaicite:0]{index=0}

Most AI documentation tools just feed raw source code into an LLM.

That works… but it’s noisy and unreliable.

Instead, I parse repositories into an Abstract Syntax Tree (AST) using Tree-sitter. This gives structured, language-aware understanding of the codebase:

Function signatures with parameters and return types
Class hierarchies
Import/export graphs
Docstring extraction
Type information

Instead of seeing “text,” the AI sees structured architecture.

Example output:

{
  type: "function_declaration",
  name: "createUser",
  parameters: [
    { name: "email", type: "string" },
    { name: "role", type: "UserRole" }
  ],
  returnType: "Promise<User>",
  docstring: "Creates a new user account"
}

That structure dramatically improves documentation quality compared to raw code prompts.

Key insight:

LLMs perform significantly better when you reduce ambiguity before prompting them.

2. AI Generation with :contentReference[oaicite:1]{index=1}

Once we have structured AST data, we feed it into Claude with carefully designed prompts.

The system generates:

API endpoint documentation
Method/function descriptions
Parameter breakdowns with types
Usage examples
High-level architecture summaries

Because the input is structured, the output is:

More consistent
Less hallucinated
Easier to regenerate deterministically

This separation — parser for understanding, LLM for explanation — keeps responsibilities clean.

3. Auto-Sync with :contentReference[oaicite:2]{index=2} Webhooks + RAG

Documentation should never be stale.

Here’s what happens when you push code:

GitHub webhook fires
We detect changed files
Tree-sitter re-parses only affected nodes
Claude regenerates relevant documentation
Embeddings update in :contentReference[oaicite:3]{index=3}

Your docs are never more than one push behind your code.

No manual updates required.

The RAG Chat System

We also built an AI chat interface over your documentation.

Instead of basic vector search, we implemented hybrid retrieval:

BM25 → precise keyword matching (function names, error codes)
Pinecone → semantic search (conceptual questions)
Reciprocal Rank Fusion (RRF) → combines both ranking systems

That means users can ask:

“How does authentication work?”

Even if the word authentication doesn’t appear directly in code, the system still finds relevant logic, middleware, or config.

Hybrid search dramatically improves answer quality compared to pure embeddings.

Tech Stack

Component	Technology
Frontend	Next.js 16 (App Router)
Backend	Express (ES Modules)
Database	PostgreSQL
Vector DB	Pinecone
AI	Claude (Anthropic)
Parser	Tree-sitter
Queue	BullMQ + Redis
Hosting	Vercel + Railway

The biggest architectural decision was separating:

Parsing layer
Generation layer
Retrieval layer

Keeping those decoupled made iteration much faster.

What I’d Do Differently

1. Start with fewer languages

Supporting 15+ languages from day one was overly ambitious.

If I rebuilt it today, I’d focus on:

JavaScript / TypeScript
Python

Nail those first. Expand later.

2. Build “Documentation Health Scores” earlier

We added a documentation health scoring system later — and surprisingly, it became one of the most loved features.

Gamification works.

Teams are far more likely to maintain docs when they can see:

Coverage %
Outdated endpoints
Missing descriptions

If I were starting again, this would be v1.

3. Use WebSockets instead of polling

We currently poll for generation status updates.

WebSockets would make the system cleaner and more real-time.

Classic v1 tradeoff: ship now, refine later.

Lessons from Building AI Dev Tools

A few high-level takeaways:

Structured input > clever prompts
Retrieval quality matters more than model size
Dev tools succeed when they reduce friction, not add AI novelty
Automation only works if it’s invisible

AI is powerful — but only when wrapped in good architecture.

Try It

AutomaDocs is live with a free tier:

3 repositories
20 AI generations/month

👉 https://automadocs.com

I’d genuinely love feedback from the dev.to community:

What’s your biggest documentation pain point right now?

[Boost]

Elizabeth Stein — Sat, 14 Feb 2026 21:59:09 +0000

Elizabeth Stein

Feb 14

I Built the First A11y CLI That Auto-Fixes Code While You Type (+ Teaches Copilot Your Patterns)

#githubcopilotclichallenge #a11y #mcp #typescript

Comments

6 min read

I Built the First A11y CLI That Auto-Fixes Code While You Type (+ Teaches Copilot Your Patterns)

Elizabeth Stein — Sat, 14 Feb 2026 17:10:20 +0000

🎬 Watch It In Action First

The Problem Nobody's Solved

Every accessibility tool tells you what's broken. None of them fix it automatically while you code.

When you scan your codebase with axe-cli, pa11y, or Lighthouse, you get a list of violations. Then you context-switch to fix them. By next week, new violations creep in. The backlog grows. Teams feel overwhelmed.

95.9% of websites still fail basic WCAG standards (WebAIM Million). That's 1 billion users who can't fully use the web.

What Makes ally Different

I built ally - an accessibility CLI with two industry-first features that no competitor has:

1. Real-Time Auto-Fix on Save

Watches your files and auto-applies WCAG fixes as you save — zero manual intervention.

$ ally watch src/ --fix-on-save

✓ Auto-fix: ON (confidence ≥ 90%)
📄 Button.tsx changed
   ✓ Auto-applied 2 fixes
   • <button> → <button aria-label="Submit">
   • <img> → <img alt="Logo">

Score: 62 → 100 ✨

Why this matters:

🔥 Instant fixes — No "fix later" backlog
🎯 High confidence — Only applies fixes ≥90% certainty
⚡ Zero friction — Edit files normally, ally handles the rest
🤖 Pattern learning — Learns from your fix history

No other accessibility tool has this. Not axe-cli. Not pa11y. Not Lighthouse.

2. Impact Scoring (0-100)

Shows which violations actually hurt users — eliminates developer overwhelm.

$ ally scan ./src

[!!!] CRITICAL Impact: 98/100 (WCAG A)
    Buttons must have discernible text
    💡 Users cannot activate buttons, blocking core actions
    👥 Affects: Screen reader users, Voice control users
    📊 Estimated: 15-20% of users

Instead of treating all violations equally, ally scores each 0-100 based on:

WCAG level (A > AA > AAA for priority)
User groups affected (screen readers, keyboard-only, low vision)
% of users impacted
Business context (checkout pages score higher for form issues)

Fix the highest-score issues first. Stop guessing.

The GitHub Copilot CLI Integration That Changes Everything

Here's where it gets interesting for this challenge.

Most submissions will say "I used Copilot to write my code."

ally goes further: I built a custom MCP (Model Context Protocol) server (2,094 lines) that teaches GitHub Copilot about YOUR accessibility patterns.

How It Works

When you install ally and run ally init, it creates .copilot/mcp-config.json:

{
  "mcpServers": {
    "ally-patterns": {
      "type": "local",
      "command": "node",
      "args": ["./node_modules/ally-a11y/mcp-server/dist/index.js"]
    }
  }
}

Now when you ask Copilot to fix accessibility issues, it gets context from 7 MCP tools:

get_component_patterns - Your existing ARIA patterns
get_design_tokens - WCAG-compliant colors from your codebase
get_fix_history - Previously applied fixes for consistency
get_scan_summary - Current accessibility violations
get_wcag_guideline - Full WCAG criterion details
suggest_aria_pattern - ARIA patterns for component types
check_color_contrast - Calculate WCAG contrast ratios

The Feedback Loop

This creates a powerful workflow:

# 1. ally scans and finds issues
$ ally scan Button.tsx
[!!!] CRITICAL: Button missing aria-label

# 2. Use Copilot with ally's context
$ gh copilot suggest "fix the button accessibility"

# Behind the scenes, Copilot calls your MCP server:
# - get_component_patterns → sees you use aria-label consistently
# - get_design_tokens → knows your color palette
# - get_fix_history → sees 47 previous aria-label fixes
# - get_scan_summary → knows this specific violation

# Result: Copilot suggests code that matches YOUR patterns
# <button aria-label="Submit form">

# 3. Apply fix and rescan
$ ally scan Button.tsx
✓ No violations found (score: 100)

# 4. Fix becomes part of your history
$ ally history
✓ Button.tsx: 62 → 100 (+38)

This is what Copilot CLI integration should look like: Not just using Copilot to build a tool, but making Copilot smarter at its job.

What I Learned Building With Copilot CLI

1. MCP Servers Are Incredibly Powerful

Building the MCP server taught me that Copilot CLI isn't just a code generator — it's an extensible platform. By giving Copilot access to project-specific context, you can transform it from "generic Stack Overflow suggestions" to "expert on your codebase."

The telemetry proves it works:

[MCP Telemetry] get_component_patterns called (47x total)
[MCP Telemetry] get_design_tokens called (23x total)
[MCP Telemetry] get_fix_history called (156x total)
[MCP Telemetry] suggest_aria_pattern called (89x total)

Real developers are using it. Copilot is getting smarter about accessibility because of ally's MCP server.

2. Context Is Everything for AI Code Generation

Generic Copilot suggestions are often wrong for accessibility because every project uses different ARIA patterns, design systems, and conventions.

The MCP server solves this by teaching Copilot your patterns, not generic ones.

3. Developer Experience > Features

ally has 19 commands, but the two that matter most solve emotional problems:

ally watch --fix-on-save (removes friction)
ally scan with impact scores (eliminates overwhelm)

Copilot CLI taught me this during development — the best features remove blockers, not add capabilities.

Why This Matters (The $200B Problem)

The Business Case:

95.9% of websites fail WCAG (WebAIM Million)
1 billion users have disabilities
ADA lawsuits increased 400% (2017-2023)
WCAG compliance is legally required (US, EU, Canada)

What ally Solves:

Eliminates overwhelm via impact scoring
Zero-friction fixes via auto-fix on save
Pattern consistency via MCP server
Compliance documentation via reports
Team education via ally learn

The Complete Toolkit (19 Commands)

# Scanning & Real-Time
ally scan ./src              # Impact scoring
ally watch --fix-on-save     # Auto-fix as you code
ally crawl <url>             # Multi-page scanning
ally scan-storybook          # Storybook integration

# Fixing & Triage  
ally fix                     # Interactive fixes
ally triage                  # Prioritize violations
ally explain                 # WCAG + Copilot tips
ally learn <topic>           # WCAG education

# Reporting & Progress
ally report                  # MD/HTML/JSON/SARIF/CSV
ally history                 # Progress trends
ally stats                   # Dashboard
ally pr-check                # GitHub PR comments

# Plus: tree, badge, audit-palette, init, doctor, health, completion

Try It Yourself (3 Commands)

# 1. Install
npm install -g ally-a11y

# 2. Initialize (creates MCP config)
ally init

# 3. Start auto-fixing
ally watch src/ --fix-on-save

With GitHub Copilot CLI:

$ gh copilot suggest "fix accessibility in Button.tsx"
# Copilot now uses ally's MCP server for project-specific context

Why This Should Win

1. Genuinely Novel Features

Real-time auto-fix (no competitor has this)
Impact scoring 0-100 (industry-first)

2. Deep Copilot Integration

Not just "built with" but "makes Copilot smarter"
2,094-line MCP server with 7 tools
Production telemetry proving real usage

3. Production-Ready

Published to npm
16,505 lines TypeScript
122+ tests
GitHub Action + SARIF output

4. Real Impact

$200B accessibility market
1 billion users affected
Solves #1 developer pain point

Technical Highlights

MCP Server (2,094 lines):

7 tools with telemetry
Pattern/token caching
Error handling
TypeScript safety

Impact Scoring:

WCAG level weighting
User group analysis
Business context
0-100 scale

Auto-Fix:

35+ patterns
Confidence threshold (≥90%)
Fix history tracking
Dry-run mode

What I Learned Building With Copilot CLI

Why accessibility matters:

95.9% of top 1 million websites have WCAG failures
1 billion people worldwide have disabilities
ADA lawsuits increased 400% from 2017-2023
WCAG compliance is legally required in many countries

What ally solves:

Eliminates overwhelm - Impact scoring shows what to fix first
Zero-friction fixes - Auto-fix on save means no backlog accumulation
Pattern consistency - MCP server ensures fixes match your codebase
Compliance documentation - Generate reports for audits

Full Command Reference

ally scan ./src              # Scan with impact scoring
ally watch --fix-on-save     # Auto-fix as you code
ally history                 # View progress over time
ally fix                     # Interactive fix approval
ally explain                 # WCAG explanations
ally report                  # Generate reports (MD/HTML/JSON/SARIF)
ally triage                  # Prioritize violations interactively
ally crawl <url>             # Multi-page website scanning
ally pr-check                # Post results to GitHub PRs
ally badge                   # Generate accessibility badges
ally learn <topic>           # Educational WCAG explainer
ally tree <url>              # View accessibility tree
ally doctor                  # Diagnose setup issues

Try It Yourself

# Install
npm install -g ally-a11y

# Initialize in your project
ally init

# Scan your project
ally scan ./src

# See what's wrong
ally explain

# Fix with AI assistance
ally fix

# Generate report
ally report

Requirements:

Node.js 18+
GitHub Copilot CLI (optional, for AI-powered explain/fix)

Specter: Give Your Codebase a Voice

Elizabeth Stein — Sat, 14 Feb 2026 13:42:11 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

Specter is a code analysis CLI that speaks as your codebase in first person. It builds a knowledge graph from your source code and git history, then uses that graph to power 66 commands across analysis, fun/shareable, daily workflow, and AI-powered categories.

The twist: Specter has personality. Your codebase literally talks about itself.

"I'm feeling pretty good about myself. My complexity hotspots are
 under control, though src/legacy/parser.ts keeps me up at night..."

Why I Built It

Developer tools are powerful but dry. Nobody shares a SonarQube report on Twitter. I wanted to build something that gives developers the insights they need (health scores, complexity hotspots, DORA metrics) while also being genuinely fun to use and share.

The result: a tool where specter roast tears your code apart with animated glitch effects, specter tinder creates a dating profile for your codebase, and specter anthem generates a theme song in 8 genres based on your actual metrics.

Key Features

Serious Analysis (that actually helps)

specter health — Health report with complexity distribution and animated score reveal
specter hotspots — Complexity x churn scatter plot with quadrant analysis
specter dora — DORA metrics for delivery performance
specter bus-factor — Knowledge concentration risks
specter coupling — Hidden couplings between files
specter cycles — Circular dependency detection
specter cost — Tech debt estimated in dollars

Fun & Shareable (that make people install it)

specter roast — Comedic codebase roast with animated glitch intro
specter tinder — Dating profile for your code with green/red flags
specter wrapped — Spotify Wrapped-style year in review
specter anthem — Stats-driven theme song (8 genres)
specter fame — Compare your codebase to famous open-source projects
specter horoscope — Daily code horoscope based on commit patterns
specter obituary <file> — Memorial for a file about to be deleted
specter seance — Summon spirits of deleted code from git history

Daily Workflow

specter morning — Daily standup briefing
specter precommit — Risk check before committing
specter predict — PR impact prediction
specter fix — Actionable fix suggestions with interactive mode
specter tour — Guided walkthrough for new developers

12 Personality Modes — Add --personality <mode> to any command: default, mentor, critic, historian, cheerleader, minimalist, noir, therapist, roast, dramatic, ghost, and more.

CI/CD Ready — Every analysis command supports --json for machine-readable output and --exit-code for quality gates.

MCP Server: 14 Tools for GitHub Copilot CLI

Specter's MCP integration is the core of this submission. One command adds it to Copilot CLI:

copilot mcp add specter -- npx @purplegumdropz/specter-mcp

Then use natural language:

copilot -p "Use specter to find complexity hotspots in my codebase"
copilot -p "Use specter to show team expertise for src/api/"
copilot -p "Use specter to analyze the impact of changing config.ts"

14 MCP tools: file relationships, complexity hotspots, codebase summary, dead code detection, symbol search, call chains, architecture diagrams, change coupling, impact analysis, bus factor, code archaeology, health trends, risk scoring, and knowledge map.

6 MCP prompt templates: specter:introduce, specter:review, specter:onboard, specter:refactor-plan, specter:standup-summary, specter:health-check

4 MCP resources: specter://summary, specter://health, specter://hotspots, specter://architecture

This means Copilot CLI can understand your entire codebase through Specter's knowledge graph — not just the files you have open, but the relationships between them, the complexity patterns, the team expertise distribution, and the historical evolution.

Demo

Install & Try

# Install globally
npm install -g @purplegumdropz/specter

# Or try without installing
npx @purplegumdropz/specter-roast

Quick Demo (30 seconds)

Watch Specter scan, diagnose, and roast a codebase in 30 seconds.

Repository

forbiddenlink / specter

Ghost-themed interactive web experience with atmospheric effects and immersive storytelling

👻 Specter

Give your codebase a voice.
A code intelligence CLI that speaks as your codebase in first person.
65 commands. 14 MCP tools. 12 personality modes. 1 ghost in your git history.

What Makes Specter Different?

Traditional analysis tools show metrics without meaning. Specter connects the dots:

The Problem	Specter's Answer
"Cyclomatic complexity: 45"	Where the hotspots are + why they matter
"Tech debt exists"	$510k annual maintenance burden (your hourly rate)
"Bus factor: 1"	Who owns what + what breaks if they leave
Numbers without context	AI-powered explanations in 12 personality modes

# Install and get started in 30 seconds
npm install -g @purplegumdropz/specter
specter scan && specter health

# Or try without installing
npx @purplegumdropz/specter-roast

Watch 30-second demo →

Real-World Examples

Find the code that's slowing your team down

specter hotspots              # Complexity × Churn = Refactoring Priority
specter cost                  # Tech debt in dollars ($510k/year)

…

View on GitHub

Screenshots

My Experience with GitHub Copilot CLI

Building Specter's MCP integration was the most technically interesting part of this project. The MCP protocol gives Copilot CLI structured access to tools, and designing the right tool surface area was a real design challenge.

What Worked Well

Copilot CLI as a natural language interface to analysis tools. Instead of remembering flag combinations like specter hotspots --top 10 --sort churn --format table, users can just say "show me the files that change the most and are most complex." Copilot CLI maps that to the right MCP tool call with the right parameters. This is a genuinely better UX for exploratory analysis.

MCP prompt templates for common workflows. The specter:onboard template gives Copilot CLI a structured way to introduce new developers to a codebase. The specter:review template combines file relationships, complexity data, and change coupling to give context-aware code review suggestions. These aren't just wrappers — they compose multiple tools in ways that would be tedious to do manually.

MCP resources for ambient context. Having specter://summary and specter://health available as resources means Copilot CLI can reference your codebase state without an explicit tool call. When you ask "should I refactor this?", it already knows your health score and hotspot distribution.

What I Learned

Design tools for AI, not just humans. MCP tools need to return structured data that an LLM can reason about. I spent time making sure tool outputs include both raw numbers and contextual descriptions — so Copilot CLI can say "this file has a bus factor of 1, meaning only one person has ever touched it" rather than just returning {"busFactor": 1}.

The personality system works surprisingly well with LLMs. When Copilot CLI pipes Specter's personality-enhanced output into its responses, the result feels conversational rather than robotic. The ghost metaphor ("I am the ghost in your git history") gives the tool a memorable identity that makes the AI interaction feel more natural.

Tech Stack

TypeScript with ts-morph for AST analysis
Commander.js for CLI framework
MCP SDK (@modelcontextprotocol/sdk) for the MCP server
chalk, gradient-string, cfonts for terminal UI
vitest for testing (313 tests across 13 files)
Biome for linting and formatting

Built by Liz Stein — "I am the ghost in your git history."

TimeSlipSearch: A Conversational Time Machine for Pop Culture

Elizabeth Stein — Mon, 09 Feb 2026 00:52:54 +0000

This is my submission for the DEV Challenge: Consumer-Facing Conversational Experiences.

What I Built

TimeSlipSearch is a conversational time machine that answers questions like:

“What was the #1 song the day I was born?”

…in under 100 milliseconds.

Type a date in plain English, like “Summer of ’69,” “Christmas 1985,” or “the day the Berlin Wall fell,” and instantly receive a complete cultural snapshot:

Billboard Hot 100 chart results
Movies in theaters
Gas prices and other economic context
Historical events from that exact moment in time

The Problem

Nostalgia is a $260B+ industry, yet exploring historical pop culture still requires jumping between Wikipedia, Billboard archives, IMDb, and economic databases.

The data exists, it’s just scattered and hard to access conversationally.

The Solution

A single unified search across 420,000+ indexed records, wrapped in an immersive VHS/CRT retro interface that makes time travel feel real.

Demo

🔗 Live: https://timeslipsearch.vercel.app

Try these queries:

July 20, 1969 — Moon landing day
Summer of ’69 — Natural language works
Compare 1989 vs 1979 — Side-by-side decades
Your birthday

How I Used Algolia Agent Studio

Indexed Data: 420K+ Records Across 4 Indices

Index	Records	What It Contains
`timeslip_songs`	350,000	Every Billboard Hot 100 entry, 1958–2020
`timeslip_movies`	50,000	Theatrical releases from TMDB
`timeslip_prices`	900	Gas, minimum wage, movie tickets (FRED)
`timeslip_events`	20,000	Historical events (Wikimedia)

Retrieval Strategy: Parallel Multi-Index Search

Every user query triggers one HTTP request that searches all four indices simultaneously:

const response = await client.search({
  requests: [
    { indexName: "timeslip_songs",  filters: `date >= ${start} AND date <= ${end}`, hitsPerPage: 10 },
    { indexName: "timeslip_movies", filters: `date >= ${start} AND date <= ${end}`, hitsPerPage: 5 },
    { indexName: "timeslip_prices", filters: `date >= ${start} AND date <= ${end}`, hitsPerPage: 1 },
    { indexName: "timeslip_events", filters: `date >= ${start} AND date <= ${end}`, hitsPerPage: 5 }
  ]
});

This batched approach is critical, sequential queries would take ~4× longer and break the conversational feel.

Prompt Engineering: Era-Aware Context Generation

Raw search results aren’t enough for conversation. I built a cultural context layer that enriches responses with era-specific narratives:

const YEAR_HIGHLIGHTS: Record<number, string> = {
  1969: "The Summer of Love peaked as humans walked on the moon.",
  1984: "MTV transformed music into a visual medium.",
  1989: "The Berlin Wall fell and hip-hop went mainstream."
  // 60+ curated year narratives
};

The agent also generates contextual follow-up suggestions based on actual results:

Found George Michael? → “Explore more from George Michael”
Searched 1988? → “See nearby: 1989 — The year the Berlin Wall fell”
First time in the 80s? → “Discover more of the 80s”

Memory System: Persistence Without Accounts

Following a retrieval + scale + memory approach, I implemented localStorage-based memory:

Search History — last 20 queries with one-click replay
Favorites — save meaningful dates with personal notes
Achievements — unlock badges for exploring different decades

This creates session continuity without requiring authentication, the agent “remembers” your journey through time.

Why Fast Retrieval Matters

TimeSlipSearch lives or dies by speed. Here’s why Algolia was essential:

1) Conversational UX requires instant responses

Chat interfaces create expectations of immediacy. A 2-second delay feels like the agent is “thinking too hard.” Algolia’s sub-100ms retrieval keeps the conversation flowing naturally.

2) Four indices, one round-trip

Without batched multi-index search, I’d need 4 sequential API calls. At ~150ms each, that’s ~600ms of network latency alone, before any processing. Algolia collapses this to a single request.

3) The retro aesthetic is decoration, not necessity

The VHS tracking lines and CRT glow are purely stylistic. Results arrive so fast that the “loading” animation is optional, users see their time capsule before the tape even finishes rewinding.

4) Numeric range filtering at scale

Searching 350,000 Billboard records by Unix timestamp range could be expensive. Algolia’s numeric filters handle it effortlessly, enabling queries like “show me everything from June 1–7, 1988” without performance degradation.

Built With

Next.js 16
Algolia v5
TypeScript
Tailwind CSS
chrono-node for natural language date parsing

Data Sources

Billboard Hot 100
TMDB
FRED Economic Data
Wikimedia

ContradictMe: An AI That Disagrees With You (For Good)

Elizabeth Stein — Mon, 09 Feb 2026 00:32:38 +0000

This is my submission for the DEV Challenge: Consumer-Facing Conversational Experiences.

What I Built

ContradictMe is an AI designed to disagree with you.

Most AI assistants are optimized to be helpful, harmless, and agreeable. ContradictMe is built to challenge your beliefs with the strongest possible counterarguments , not to be contrarian, but to make you think better.

The Problem

We’re drowning in agreement.

Social algorithms feed us content that confirms what we already believe. AI assistants optimize for satisfaction. The result is echo chambers everywhere.

The consequences are real:

Students graduate without learning to defend their ideas
Professionals make decisions without stress-testing assumptions
Public discourse becomes tribal, we don’t even understand the other side anymore

The Solution

ContradictMe weaponizes disagreement for good. Tell it something you believe strongly, and it will:

Steel-man the opposition , present the strongest version of counterarguments, not weak straw-men
Cite real research , every claim backed by credible sources and scored for quality
Acknowledge nuance , flags limitations, mixed evidence, and where you might actually be right
Spark deeper thinking , ends with reflection questions that stay with you

It’s not about changing minds. It’s about strengthening them.

Demo

🔗 https://contradict-me.vercel.app

Core Experience: Challenge Your Beliefs

Enter any belief, for example:

“Remote work is always better”
“AI will take all jobs”
“College isn’t worth it”

…and get a thoughtful, evidence-based counterargument in seconds.

What you’ll see:

Quality scores (0-100) for each argument
Source credibility badges (peer-reviewed, institution, citation count)
Explicit limitations (example: “This study only examined tech workers”)
Follow-up questions to explore further

AI Debate Arena

Can’t decide what to think? Watch two AI agents battle it out.

Enter a topic and watch:

Logical Larry (evidence-focused)
Emotional Emma (values-focused)

…debate through 5 structured rounds. You can:

Interject with your own questions mid-debate
Vote for the winner
Export the full transcript

Analytics & Achievements

Track your intellectual journey:

Topics explored (tag cloud visualization)
Arguments encountered
Critical thinking achievements (example: “Renaissance Mind” for exploring 5+ topics)

Full Feature List

Dark/light/system themes (keyboard shortcut: ⌘⇧L)
Conversation history with search + bookmarks
Export conversations (JSON, Markdown, TXT)
WCAG accessibility compliance
Streaming responses with elegant loading states

How I Used Algolia Agent Studio

Architecture Overview

User belief → Agent Studio (GPT-4) → Algolia Search → ranked arguments → synthesized response

The magic is in how retrieval and generation work together.

1) Curated Argument Database

I didn’t index random content. I built a curated database of 26 research-backed arguments across controversial topics:

Work

Remote productivity
4-day workweek
Gig economy

Economics

Minimum wage
UBI
Cryptocurrency
Housing policy

Technology

AI displacement
EVs
Social media effects
Space funding

Social

Gun policy
Immigration
Drug decriminalization

Health/Education

Plant-based diets
Healthcare systems
College ROI

Each argument is structured for optimal retrieval. Example record shape:

{
  "objectID": "remote-work-innovation",
  "position": "against_remote_work",
  "opposingBeliefs": ["remote work is always better", "offices are obsolete"],
  "mainClaim": "Innovation often depends on unplanned collaboration",
  "evidence": "Summary of findings and key results...",
  "supportingPoints": [
    "Spontaneous cross-team idea flow",
    "Whiteboard brainstorming sessions",
    "Mentorship through observation"
  ],
  "limitations": "Context limits, population limits, or mixed evidence notes...",
  "sourceMetadata": {
    "title": "Innovation Patterns in Distributed Teams",
    "authors": ["Author One", "Author Two"],
    "institution": "Example University",
    "publicationType": "peer-reviewed",
    "yearPublished": 2024,
    "citationCount": 847,
    "doi": "10.xxxx/xxxx.xxxx"
  },
  "qualityScore": 87,
  "sourceCredibility": 95,
  "evidenceStrength": 85
}

Average quality score across the database: 88.1 / 100

2) Search Configuration

Key idea: rank by quality, not just relevance.

// Searchable attributes
searchableAttributes: [
  "mainClaim",
  "evidence",
  "supportingPoints",
  "opposingBeliefs",   // key: matches user's stated belief
  "metadata.tags",
  "metadata.domain"
],

// Custom ranking - quality over relevance
customRanking: [
  "desc(qualityScore)",
  "desc(sourceCredibility)",
  "desc(evidenceStrength)"
],

// Faceting for filtering
attributesForFaceting: [
  "filterOnly(position)",
  "searchable(metadata.domain)",
  "filterOnly(sourceMetadata.yearPublished)"
]

The opposingBeliefs field is crucial, it’s how the agent matches “I believe remote work is better” to arguments that oppose that position.

3) Prompt Engineering for Steel-Manning

System prompt principles:

Acknowledge the user’s perspective, don’t dismiss it
Retrieve the strongest counterarguments (steel-man, not straw-man)
Present 2-3 top-ranked arguments with:
- Core claim
- Supporting evidence + quality indicators
- Source attribution (authors, institution, year)
- Explicit limitations or caveats
Note where the user’s belief has valid points
End with a thought-provoking question

Tone rules: never condescending, never attack the person, challenge ideas with evidence and curiosity.

4) Streaming Integration (SSE)

The frontend uses Server-Sent Events (SSE) for real-time streaming so the response feels like the AI is reasoning in front of you.

const response = await fetch(agentEndpoint, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    messages: [{ role: "user", parts: [{ text: userBelief }] }],
    stream: true,
    compatibilityMode: "ai-sdk-5"
  })
});

// Stream chunks to client
for await (const chunk of response.body) {
  // Parse SSE format and forward to UI
}

Why Fast Retrieval Matters

Speed isn’t a nice-to-have for ContradictMe, it’s essential to the psychology of the experience.

When someone shares a deeply-held belief, they’re in a narrow window of openness. If the system is slow, defenses come back up and they start preparing rebuttals before they even read the response.

Fast (< 2s): user stays engaged and receptive
Slow (> 5s): user disengages or “armors up”

Algolia’s fast search lets the agent retrieve, rank, and synthesize arguments before that window closes.

Real Performance Numbers

Metric	Result
Average belief-to-first-token	1.2 seconds
Full response completion	4-6 seconds
Debate Arena (10 retrievals)	Smooth, no lag
Tests passing	73 / 73

The Debate Arena Stress Test

Each 5-round debate requires:

10 argument retrievals (5 per side)
real-time synthesis
awareness of prior rounds

With slower retrieval, this feature wouldn’t feel usable. With Algolia, it feels like watching two informed debaters go head-to-head in real time.

The Bigger Picture

ContradictMe isn’t just a demo, it’s a proof of concept for a different kind of AI.

What if we built systems that made us better thinkers, not just more efficient workers? What if disagreement was a feature, not a bug?

Algolia Agent Studio made this possible by combining:

fast semantic search over structured argument data
GPT-4 synthesis for nuanced responses
streaming delivery for conversational flow

The result is an AI that respects you enough to disagree.

🔗 https://contradict-me.vercel.app

StanceStream – Real-Time Multi-Agent AI Debates Powered by Redis

Elizabeth Stein — Sun, 10 Aug 2025 19:56:02 +0000

This is a submission for the Redis AI Challenge: Beyond the Cache.

What I Built

StanceStream is a production-ready, multi-agent AI debate engine that transforms political discussions into live, evolving simulations.
Built entirely on Redis 8, it goes far beyond caching by orchestrating all four Redis data models in a single architecture to power intelligent agents with persistent personalities, memory-driven reasoning, real-time stance evolution, and advanced fact-checking.

The result is a fully operational real-time AI platform that demonstrates how Redis can serve as the primary data layer for a complex, high-performance AI application — handling everything from semantic search and live analytics to event streaming and structured data storage.

Demo

Live app: https://stancestream.vercel.app/
Repo: https://github.com/forbiddenlink/stancestream

Demo Highlights:
-4-mode navigation: Standard debate, Multi-debate viewer, Analytics dashboard, Business metrics
-Real-time stance charts tracking position changes during debates
-Semantic Cache Dashboard showing live Redis Vector operations
Multi-agent debates: SenatorBot vs ReformerBot on 8+ political topics
-Topic synchronization ensuring accurate stance tracking across all components

How I Used Redis 8

RedisJSON – Complex Data Structures
-Stores detailed agent profiles with nested personality traits, evolving political stances, and emotional states
-Tracks cache metrics, contest scoring, and AI-generated key moment summaries
-Maintains intelligence metrics for emotional trajectory analysis

Redis Streams – Real-Time Messaging
-Broadcasts public debate messages via WebSocket to all clients
-Maintains private agent memory streams for strategic reasoning and coalition building
-Logs message history with pagination for replay and context

RedisTimeSeries – Time-Based Analytics
-Tracks stance evolution over time for each agent
-Records emotional shifts influencing responses
-Captures performance metrics for live optimization and momentum tracking

Redis Vector – Semantic Intelligence
-Runs semantic caching with an 85% similarity threshold, achieving 70%+ hit rates
-Powers fact-checking by comparing claims across multiple knowledge bases using COSINE similarity
-Isolates topics to prevent cross-contamination between debates
-Uses OpenAI text-embedding-ada-002 for high-quality embeddings

Beyond the Cache
StanceStream demonstrates Redis as far more than a cache — it’s the real-time AI backbone for an application that merges natural language reasoning, fact verification, and live analytics.
By combining RedisJSON, Streams, TimeSeries, and Vector Search, the system delivers intelligent, personality-driven debates with business-ready dashboards, semantic intelligence, and millisecond-level responsiveness.

This project proves Redis can function as a complete, multi-model primary database for advanced AI workloads, pushing the limits of what’s possible in real-time applications.

StanceStream – Real-Time Multi-Agent AI Debates Powered by Redis

Elizabeth Stein — Sun, 10 Aug 2025 19:49:04 +0000

This is a submission for the Redis AI Challenge: Real-Time AI Innovators.

What I Built

StanceStream is a production-ready, multi-agent AI debate engine that turns political discussions into live, evolving simulations.
It uses all four Redis 8 data models in a single cohesive system to power intelligent agents with persistent personalities, memory-driven reasoning, stance evolution tracking, and real-time fact-checking.

This is not just a demo — it’s a fully operational real-time AI platform built for performance, scalability, and contest readiness.

Key Features:
-Real-time debates between intelligent AI agents with distinct political personalities
-Semantic caching engine achieving 70%+ hit rates with Redis Vector search
-Live stance evolution tracking using RedisTimeSeries
-Multi-agent intelligence with emotional states and coalition building
-Advanced fact-checking with multi-source verification and confidence scoring
-Business intelligence dashboard showing ROI and cost savings
-Concurrent debate support with topic isolation across all components
-Performance optimization via live metrics engine

Demo

Live app: https://stancestream.vercel.app/

Repo: https://github.com/forbiddenlink/stancestream

Highlights:
-4-mode navigation: Standard debate, Multi-debate viewer, Analytics dashboard, Business metrics
-Real-time stance charts: Track position changes during the debate
-Semantic Cache Dashboard: Live Redis Vector operations in action
-Agent battles: SenatorBot vs ReformerBot on 8+ political topics
-Topic synchronization: Ensures accurate stance tracking in multi-agent debates

How I Used Redis 8

*RedisJSON – Complex Data Structures
-Stores rich agent profiles with nested personality traits, evolving political stances, and emotional states
-Tracks cache metrics, contest scoring, and key moments with AI-generated summaries
-Maintains intelligence metrics for emotional trajectory analysis
*Redis Streams – Real-Time Messaging
-Broadcasts public debate messages via WebSocket to all connected clients
-Maintains private agent memories for strategic reasoning and coalition building
-Logs message history with pagination for replay and context management
*RedisTimeSeries – Time-Based Analytics
-Tracks stance evolution over time for each agent
-Measures emotional shifts that influence debate responses
-Records system performance metrics for live optimization
-Monitors debate momentum and trend patterns
*Redis Vector – Semantic Intelligence
-Runs semantic caching with an 85% similarity threshold, achieving 70%+ hit rates
-Powers the fact-checker, comparing claims against multiple knowledge bases using COSINE similarity
-Isolates topics to prevent cross-contamination between debates
-Uses OpenAI text-embedding-ada-002 (1536 dimensions) for high-quality embeddings

Advanced Redis Features
-Vector search with topic filtering to maintain cache accuracy
-Real-time Redis optimization with live performance tuning
-Concurrent connection management with automatic cleanup
-Enterprise-grade error handling and reconnection strategies
Memory-efficient operations using data retention policies

Production-Ready Architecture
-Centralized Redis connection manager with health monitoring
-WebSocket broadcasting to multiple clients for instant updates
-Background process orchestration for long-running simulations
-Comprehensive logging and live performance metrics

Why It’s Unique
StanceStream proves Redis is far more than a cache — it’s a complete real-time AI backbone.
By orchestrating multiple data models in a single architecture, it delivers intelligent, personality-driven debates with live analytics, semantic reasoning, and fact verification at scale.
This project demonstrates how Redis 8 can drive high-performance, multi-model AI applications in production environments, showcasing true real-time intelligence.

🌟 Quantum Forge - Dream Intranet Portal

Elizabeth Stein — Mon, 28 Jul 2025 06:50:33 +0000

This is a submission for Frontend Challenge: Office Edition sponsored by Axero, Holistic Webdev: Office Space

What I Built

I created Quantum Forge, an employee portal that transforms the traditional intranet concept into a spectacular digital workspace. This isn't just another corporate portal—it's a dream intranet that showcases what's possible when you combine technical excellence with creative innovation.

Key Features:
35+ Custom Web Components built with vanilla JavaScript
AI-Powered Task Management with visual workflow optimization
Real-Time Analytics Dashboard with memory-optimized Chart.js integration
Interactive Office Visualizer with 3D workspace booking
Dynamic Color Theming with HSL-based real-time customization
18 Fully Functional Pages (exceeds contest requirements)
100% Accessible with WCAG 2.1 AA compliance
Spectacular Visual Effects with 60FPS animations and glassmorphism design
The portal features everything a modern workplace needs: task management, team collaboration, analytics insights, event planning, document management, and even an interactive office floor plan for desk booking. Every element has been crafted to provide an intuitive, engaging user experience that makes work feel less like work.

Demo

https://quantum-forge-intranet.netlify.app/ Experience the full portal functionality

https://github.com/forbiddenlink/quantum-forge

Journey

The Challenge
Creating a dream intranet with only HTML, CSS, and JavaScript seemed daunting at first. How do you build something that feels modern and sophisticated without frameworks? The answer was Web Components and a service-based architecture that rivals any framework-based solution.

Design Innovation: Glassmorphism Meets Functionality
I'm particularly proud of the glassmorphism design system that makes every component feel like it's floating in space while maintaining perfect readability and accessibility. The dynamic color theming system uses HSL values to generate entire color palettes in real-time.

Performance Mastery
Memory management was crucial, especially with Chart.js integration. I built a centralized ChartManager service that prevents memory leaks.

Accessibility First
Every component includes comprehensive accessibility features:

ARIA labels and landmarks
Keyboard navigation support
Screen reader announcements
High contrast mode support
Reduced motion preferences
CSS Architecture Excellence
I developed advanced CSS cleanup tools that reduced duplicates by 92% (from 344 to 27). The modular CSS architecture with systematic imports ensures maintainable, performant styling.

What I Learned
Vanilla JavaScript is Powerful - You don't need frameworks to build sophisticated applications
Web Components are the Future - They provide framework-like organization with zero dependencies
Performance Matters - Real-time monitoring and optimization make applications feel magical
Accessibility is Non-Negotiable - Building inclusively from the start is easier than retrofitting
CSS Grid is Amazing - Modern CSS layout capabilities rival any framework
Proudest Achievements
Zero Build Dependencies - Just open index.html and it works
35+ Reusable Components - Each component is a self-contained, reusable piece
100% Functional Interface - Every button, link, and interaction works perfectly
Technical Innovation - Features like the 3D office visualizer push web boundaries
Enterprise Quality - Code quality and architecture suitable for production use
The most rewarding moment was when everything came together - watching the aurora particle effects dance behind the glassmorphism cards while real-time data updates smoothly, all running at 60fps with perfect accessibility. It proves that with creativity and technical skill, pure web technologies can create experiences that rival any modern framework.

This project represents hours of passionate development, pushing the boundaries of what's possible with vanilla web technologies while maintaining the highest standards of accessibility, performance, and user experience.

🏆 Built with ❤️ for the Frontend Challenge: Office Edition

Quantum Forge - Where spectacular design meets technical excellence

License
MIT License - Feel free to use this code in your own projects!

Zoom Grid Mayhem

Elizabeth Stein — Thu, 17 Jul 2025 11:50:42 +0000

This is a submission for Frontend Challenge: Office Edition sponsored by Axero, CSS Art: Office Culture.

Inspiration

"You're still on mute."
We've all heard it. With Zoom Grid Mayhem, I wanted to playfully capture the chaos, comedy, and sometimes downright awkwardness of virtual meetings. Inspired by the endless tiles of distracted coworkers, surprise cat cameos, and mysterious ceiling fan views, I built a mini art piece that turns the typical Zoom call into an interactive, animated CSS grid party. It’s a love letter (or a warning?) to remote office life.

Demo

🎮 Check out the mayhem: https://zoomgridmayhem.netlify.app/

Feel free to view the source code via browser inspect tools or fork your own version!
https://github.com/forbiddenlink/zoom-grid-mayhem

Journey

I started with a simple grid layout to mimic a typical video call screen and let my imagination run wild. Using only HTML and CSS (with a tiny dash of animation), I styled each "participant" to reflect common—and absurd—video meeting moments:
The person who's frozen.
The one clearly working out during the call.
Pets taking over the webcam.

One of the most fun parts was experimenting with expressive CSS styles and animations to give each tile its own "personality" using minimal markup. I avoided JavaScript to stay within the spirit of CSS art, relying on @keyframes, :hover states, and creative use of ::before and ::after.

I learned how powerful CSS Grid and creative constraints can be—especially when you're trying to express real-world chaos using code.

I’d love to expand this with user-generated mayhem tiles, randomize the grid chaos, and maybe even build a “live meeting” version that lets users join in. For now, this piece stands as a pixelated tribute to the beautiful absurdity of remote work.

DEV Community: Elizabeth Stein

My Bartending Job Taught Me More About Software Than School Did

1. User Experience Is Everything

2. Handle Production Issues in Real Time

3. Communication > Technical Perfection

4. Scope Creep Is Real (and You Have to Say No)

5. You Learn More By Doing Than By Studying

6. People Don't Care How Hard It Was

What This Actually Means

My Advice If You're Career Switching

I built HireReady: AI voice interviews + spaced repetition for tech interview prep

What is it?

The problem

What it does

Tech stack

Try it out

How I Built an AI Documentation Engine with Tree-sitter, Claude AI, and RAG

The Real Problem

The Architecture

1. Code Analysis with :contentReference[oaicite:0]{index=0}

2. AI Generation with :contentReference[oaicite:1]{index=1}

3. Auto-Sync with :contentReference[oaicite:2]{index=2} Webhooks + RAG

The RAG Chat System

Tech Stack

What I’d Do Differently

1. Start with fewer languages

2. Build “Documentation Health Scores” earlier

3. Use WebSockets instead of polling

Lessons from Building AI Dev Tools

Try It

[Boost]

I Built the First A11y CLI That Auto-Fixes Code While You Type (+ Teaches Copilot Your Patterns)

I Built the First A11y CLI That Auto-Fixes Code While You Type (+ Teaches Copilot Your Patterns)

🎬 Watch It In Action First

The Problem Nobody's Solved

What Makes ally Different

1. Real-Time Auto-Fix on Save

2. Impact Scoring (0-100)

The GitHub Copilot CLI Integration That Changes Everything

How It Works

The Feedback Loop

What I Learned Building With Copilot CLI

1. MCP Servers Are Incredibly Powerful

2. Context Is Everything for AI Code Generation

3. Developer Experience > Features

Why This Matters (The $200B Problem)

The Complete Toolkit (19 Commands)

Try It Yourself (3 Commands)

Why This Should Win

Technical Highlights

Links

What I Learned Building With Copilot CLI

Full Command Reference

Try It Yourself

Links

Specter: Give Your Codebase a Voice

What I Built

Why I Built It

Key Features

MCP Server: 14 Tools for GitHub Copilot CLI

Demo

Install & Try

Quick Demo (30 seconds)

Repository

forbiddenlink / specter

Ghost-themed interactive web experience with atmospheric effects and immersive storytelling

👻 Specter

What Makes Specter Different?

Real-World Examples

Find the code that's slowing your team down

Screenshots

My Experience with GitHub Copilot CLI

What Worked Well

What I Learned

Tech Stack

TimeSlipSearch: A Conversational Time Machine for Pop Culture

What I Built

The Problem

The Solution

Demo