convez.ai
SkillDesenvolvimento WebAvançado
jonaselkabouli

Interview Me

jonaselkabouli/interview-me

Entrevistador arquiteto que valida ideias antes de você codificar

Ver no GitHub
InicialPluginScore · de 0 a 100

Skill 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-me

1 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

Estrelas
1
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 7 meses
Versão
—
Issues abertas
0
Contribuidores
1

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.

License: MIT Agent Skills Claude Code


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:

CheckWhat it looks for
MaintenanceLast release, commit activity, open issues
AdoptionGitHub stars, npm/PyPI downloads, community size
MaturityStable vs. beta vs. deprecated vs. abandoned
AlternativesBetter-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-meTypical AI spec workflow
Reads codebase before askingYes — never asks discoverable questionsNo — starts from scratch
Challenges your ideasYes — active pushback with reasoningNo — records passively
Validates tech choicesYes — live web search for every library/frameworkNo — accepts whatever is suggested
Security enforcementHard block — won't proceed until addressedMention in passing, if at all
Spec qualityAI-native — clear prose, examples, intent, non-goalsVague prose or over-formal requirement docs
Coverage trackingVisual map, one question at a timeUnstructured conversation
Decisions audit trailFull log of disagreements and resolutionsNothing
Spec → plan transitionEnters plan mode for collaborative implementation planningJumps 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):

ToolPurpose
Read, Glob, GrepCodebase pre-analysis
BashRunning project commands during analysis
AgentForking exploration subagents
AskUserQuestionStructured interview questions
WebSearch, WebFetchTechnology validation
Write, EditSpec 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

License

MIT

Ver o original no GitHub

Bom para

Relacionados