Interview Me
jonaselkabouli/interview-me
Entrevistador arquiteto que valida ideias antes de você codificar
Ver no GitHubSkill para Claude que conduz entrevistas rigorosas e cientes do codebase antes de implementar features. Valida escolhas tecnológicas contra dados reais, questiona contradições e produz especificações production-grade que agentes de IA conseguem seguir sem ambiguidade.
Instalação
npx convez-ai jonaselkabouli/interview-me1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Validar requisitos de features antes de implementação
- Questionar escolhas tecnológicas com dados de mercado
- Identificar riscos de segurança e edge cases
- Gerar especificações claras para agentes de IA construírem
Veredito

Excelente para times que querem rigor arquitetônico antes de codificar. O pushback ativo e validação tecnológica salvam semanas de refatoração. Requer disciplina do usuário em responder entrevistas completas, mas compensa em specs robustas.
README
A tradução para o português deste README ainda está na fila.
interview-me
Codebase-aware spec interviewer for AI coding agents. Reads your project first, conducts a rigorous 1-on-1 interview, validates every technology choice against real-world data, and produces a production-grade specification.
The problem with plan mode
AI coding agents are great at planning. Give them a feature request and they'll sketch an architecture, pick libraries, design data models, and start building — all in seconds. But that speed hides a fundamental gap: the agent never stops to question whether the plan is actually right.
It won't ask if the library it picked is still maintained. It won't push back when your approach contradicts something you said ten minutes ago. It won't flag that you're over-engineering a simple feature or ignoring a security concern. It just builds what sounds reasonable — and you find out it wasn't reasonable three days into implementation.
interview-me is a structured alternative. Instead of jumping to code, it conducts a rigorous interview first — one question at a time, with active pushback, technology validation against real-world data, and security hard blocks. The spec it produces is something a developer can actually build from without guessing.
What it does
interview-me is an opinionated collaborative architect that:
- Reads your codebase first — analyzes architecture, patterns, and dependencies before asking a single question. Never asks what it can learn from code.
- Interviews one question at a time — with a visual coverage tracker and well-crafted options that represent genuinely different approaches.
- Pushes back on bad ideas — challenges contradictions, over-engineering, missing edge cases, and security risks directly.
- Validates every technology choice — searches the web for maintenance status, adoption metrics, deprecation notices, and better alternatives. Flags problems before you commit.
- Hard-blocks on security risks — refuses to write the spec until auth, PII, and injection concerns are addressed.
- Produces AI-native specs — clear prose with concrete examples, code snippets, and data shapes. Written so you can hand it to an AI coding agent and say "build this."
- Transitions into plan mode — after the spec, enters Claude Code's native plan mode so you can collaboratively map the spec to code changes before implementation starts.
Install
One-liner
git clone https://github.com/jonaselkabouli/interview-me.git ~/.claude/skills/interview-me
Manual
Download SKILL.md and place it at:
~/.claude/skills/interview-me/SKILL.md
Usage
/interview-me "add real-time notifications to the dashboard"
/interview-me specs/payment-integration-brief.md
The skill accepts either a free-text requirement or a path to a requirements file.
How it works
Phase 1 — Pre-Analysis
Before the first question, an exploration agent scans your codebase:
- Existing architecture and patterns
- Tech stack, framework versions, dependencies
- Project docs (README, CLAUDE.md, existing specs)
- Constraints from integrations and deployment targets
This analysis ensures every interview question requires genuine human judgment — not information already in the code.
Phase 2 — Interview
One question at a time. Each question uses structured options (2–4 choices representing real trade-offs). A coverage map tracks progress:
Coverage: Problem [done] | Users [done] | API Design [current] | Data Model [pending] | Security [pending]
Active pushback: If you propose something that contradicts a previous answer, over-engineers the scope, or misses an edge case — the skill challenges you directly. If you disagree, it stress-tests the decision with follow-up questions, then logs both perspectives.
Technology validation: When any technology is proposed (by you or by the AI), the skill searches the web to verify:
| Check | What it looks for |
|---|---|
| Maintenance | Last release, commit activity, open issues |
| Adoption | GitHub stars, npm/PyPI downloads, community size |
| Maturity | Stable vs. beta vs. deprecated vs. abandoned |
| Alternatives | Better-maintained options for the same job |
If a library hasn't been updated in 12+ months, is officially deprecated, or has a significantly better alternative — you'll know before it ends up in your architecture.
Security hard blocks: Unaddressed PII handling, auth bypass risks, injection vectors, plaintext secrets, or missing rate limiting will block spec generation until explicitly resolved.
Phase 3 — Spec Generation
The spec structure is driven by what the interview revealed — no fixed template. Sections are generated dynamically. Common outputs include:
- Overview, Goals & Non-Goals
- Technical Design with validated technology choices
- Data Model, API Design
- Error Handling & Edge Cases
- Security Considerations
- Technology Decisions — table with status, alternatives considered, and rationale
- Decisions Log — full audit trail of pushback and resolutions
- Implementation Order — dependency-aware build sequence
Specs are written as clear, opinionated prose — not formal requirement documents. Every decision includes the reasoning so the AI building it understands intent, not just instructions. Non-goals are explicit so nothing gets over-scoped.
See examples/example-spec.md for a complete output.
Phase 4 — Plan Mode
After the spec is written, the skill transitions into Claude Code's native plan mode with the spec as the foundation. You collaborate on the implementation plan together — mapping requirements to code changes, identifying the critical path, and defining verification steps.
When the plan is approved, you exit plan mode and implementation begins — with a spec and plan that were actually questioned before a single line of code was written.
What makes this different
| interview-me | Typical AI spec workflow | |
|---|---|---|
| Reads codebase before asking | Yes — never asks discoverable questions | No — starts from scratch |
| Challenges your ideas | Yes — active pushback with reasoning | No — records passively |
| Validates tech choices | Yes — live web search for every library/framework | No — accepts whatever is suggested |
| Security enforcement | Hard block — won't proceed until addressed | Mention in passing, if at all |
| Spec quality | AI-native — clear prose, examples, intent, non-goals | Vague prose or over-formal requirement docs |
| Coverage tracking | Visual map, one question at a time | Unstructured conversation |
| Decisions audit trail | Full log of disagreements and resolutions | Nothing |
| Spec → plan transition | Enters plan mode for collaborative implementation planning | Jumps straight to code |
Compatibility
Built for Claude Code. Follows the Agent Skills open standard — compatible with any agent that supports SKILL.md files.
Required tool access
The skill uses these tools (declared in SKILL.md frontmatter):
| Tool | Purpose |
|---|---|
Read, Glob, Grep | Codebase pre-analysis |
Bash | Running project commands during analysis |
Agent | Forking exploration subagents |
AskUserQuestion | Structured interview questions |
WebSearch, WebFetch | Technology validation |
Write, Edit | Spec file generation |
When to use it
Use interview-me for:
- New features or integrations where architecture decisions matter
- Requirements that involve technology choices you haven't validated
- Features touching multiple domains or services
- Anything where getting the spec wrong means expensive rework
Skip it for:
- Bug fixes (just fix it)
- Small tweaks or refactors
- Work continuing from an existing spec