convez.ai
Skill
badrusiddique

enggenie-skill

badrusiddique/enggenie-skill

Ver no GitHub
InicialPluginScore · de 0 a 100

Role-based SDLC skill suite for AI coding assistants — PM · Architect · Dev · Reviewer · QA · Deploy

Instalação

$npx convez-ai badrusiddique/enggenie-skill

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
0
Forks
0
Acompanhando
0
Saúde
57%
Último commit
há 1 mês
Versão
v3.0.0
Issues abertas
0
Contribuidores
1

README

A tradução para o português deste README ainda está na fila.

enggenie

"every skill is a domain expert that activates when you need it and stays silent when you don't."

Role-based AI skills that cover the full software development lifecycle - from vague idea to shipped PR - without letting your AI cut corners.


Without enggenie:

You: "Add a user profile feature."
AI: Writes 200 lines of code. No plan. No tests. No review.
You: Spend 3 days in review cycles, find 2 bugs in QA, rewrite 30% after spec ambiguity.

With enggenie:

You: "Add a user profile feature."
→ pm-refine creates a spec with requirements, edge cases, and a QA plan
→ dev-plan phases the work into independently deployable chunks
→ dev-implement enforces TDD - failing test before any code, green before moving on
→ review-code runs security, engineering, and test lenses in parallel (new in v3.0.0)
→ qa-verify requires actual evidence before any "done" claim
→ deploy-ship creates the PR with full spec context for your reviewers

Result: Ships clean. Tests prove it. Your team can read what was built and why.

What it looks like

Here is a compressed real session. The project is a Next.js + TypeScript + Firebase heist-themed game. The task: add a player inventory system.

Step 1 - dev-implement writes a failing test first:

// src/services/inventory/player-inventory.test.ts
import { addItemToInventory, getInventory } from './player-inventory';
import { db } from '@/lib/firebase';

vi.mock('@/lib/firebase');

describe('player inventory', () => {
  it('adds an item and returns updated inventory', async () => {
    const mockGet = vi.fn().mockResolvedValue({ exists: () => false });
    const mockSet = vi.fn().mockResolvedValue(undefined);
    (db.collection as vi.Mock).mockReturnValue({
      doc: () => ({ get: mockGet, set: mockSet }),
    });

    const result = await addItemToInventory('session-abc', 'lockpick');

    expect(mockSet).toHaveBeenCalledWith(
      expect.objectContaining({ items: ['lockpick'] })
    );
    expect(result.items).toContain('lockpick');
  });
});
$ npx vitest run src/services/inventory/player-inventory.test.ts

 FAIL  src/services/inventory/player-inventory.test.ts
   Cannot find module './player-inventory'

Test Files  1 failed (1)
Tests       0 failed | 0 passed | 1 skipped
Duration    312ms

RED. Test exists. Implementation does not. That is the correct order.

Step 2 - minimal implementation:

// src/services/inventory/player-inventory.ts
import { db } from '@/lib/firebase';

export async function addItemToInventory(sessionId: string, item: string) {
  const ref = db.collection('sessions').doc(sessionId);
  const snap = await ref.get();
  const current = snap.exists() ? (snap.data()?.items ?? []) : [];
  const updated = [...current, item];
  await ref.set({ items: updated }, { merge: true });
  return { sessionId, items: updated };
}

export async function getInventory(sessionId: string) {
  const snap = await db.collection('sessions').doc(sessionId).get();
  return snap.exists() ? snap.data()?.items ?? [] : [];
}
$ npx vitest run src/services/inventory/player-inventory.test.ts

 PASS  src/services/inventory/player-inventory.test.ts
   player inventory
     ✓ adds an item and returns updated inventory (23ms)

Test Files  1 passed (1)
Tests       1 passed (1)
Duration    287ms

GREEN.

Step 3 - review-code security lens flags something:

[Security Lens] BLOCKING: addItemToInventory accepts arbitrary item strings
with no validation against a known-item allowlist. A malicious client could
inject item: "<script>alert(1)</script>" or item: "admin_key" into any
session. Add an ITEMS_ALLOWLIST constant and validate before writing.

Severity: Blocking - do not merge without fixing.

The implementer adds the allowlist and a test for the rejection case before proceeding.

Step 4 - qa-verify requires proof:

$ npx vitest run --reporter=verbose

 PASS  src/services/inventory/player-inventory.test.ts (3 tests)
 PASS  src/components/InventoryPanel.test.tsx (7 tests)
 PASS  src/app/api/inventory/route.test.ts (4 tests)

Test Files  3 passed (3)
Tests       14 passed (14)
Duration    1.84s
Exit code: 0
qa-verify: 14 tests passed, exit 0. Coverage: inventory module 94%.
Completion claim is substantiated. Proceeding to deploy-ship.

How it works

flowchart LR
    PM["PM\npm-refine\n---\nspec + QA plan"] --> Design["Design / Plan\ndev-brainstorm\ndev-plan\n---\nADRs + phases"]
    Design --> Build["Build\ndev-implement\ndev-tdd\n---\nTDD enforced"]
    Build --> Review["Review\nreview-code\nreview-design\n---\n3-lens analysis"]
    Review --> Ship["Ship\nqa-verify\ndeploy-ship\n---\nevidence-based"]

Each node is a role with dedicated skills and a concrete output artifact. The PM hands off to Dev for design and planning. Dev builds and hands off to the Reviewer. The Reviewer hands off to QA and Ship. When different people handle different phases, a Jira ticket carries the context between sessions automatically.


The skills

RoleSkillWhat It DoesWhat You GetTry Saying...
PMpm-refineGenerates specs, refines stories, estimates pointsenggenie/spec_*.md with requirements, edge cases, QA plan"Write a spec for player inventory"
Devdev-brainstormBrainstorms approaches, writes architecture decision recordsenggenie/adr_*.md with options, decision, consequences"What's the best way to handle timer sync?"
Devdev-planCreates phased implementation plansenggenie/plan_*.md with tasks, dependencies, readiness checks"Create a plan from this spec"
Devdev-implementExecutes plans with TDD subagentsCode, tests, per-task commits with spec traceability"Execute Phase 1 of the plan"
Devdev-tddEnforces RED-GREEN-REFACTOR on every changeFailing test, then implementation, then refactor"Add a validateSessionCode function"
Devdev-debug4-phase systematic root cause investigationRoot cause + targeted fix + regression test"This Firebase listener is firing twice"
Reviewerreview-code3-lens parallel review: security, engineering, testRanked findings: Blocking / Advisory / Observation"Review my changes before I push"
Reviewerreview-designChecks UI against design system, states, a11yCompliance report with specific gaps"Does this match the Figma?"
QAqa-verifyRequires evidence before any completion claimTest run output with exit code and counts"Are we done? Prove it."
QAqa-testPlaywright automation + manual browser testingTest scripts + annotated screenshots"Test the heist session join flow"
Devdev-commitAnalyzes diffs, proposes conventional commit messagesConventional commit ready to stage"Commit this"
Deploydeploy-shipPR creation, Jira handoff updates, branch completionOpen PR with spec context and dev notes"Create a PR for this branch"
Memorymemory-recallCross-session context with 10x token savingsSummary of prior decisions and patterns"What pattern did we use for auth tokens?"
GatewayenggenieRoutes to the right skill when intent is ambiguousCorrect skill activates for your context"Help me work on PROJ-1234"

Why teams adopt it

For Engineering Managers

Code review quality is inconsistent by nature - it depends on who is reviewing that week, whether they caught the auth issue, whether they noticed the missing test coverage. With enggenie, every PR gets the same three lenses regardless of team composition. Security, engineering principles, and test coverage are checked on every diff. Review quality stops being a function of who happened to have bandwidth.

For Developers

"I always say I'll write tests first. I almost never do when I'm under pressure." dev-tdd removes the option. It will not move forward until the test is red. That constraint turns out to be useful when you're under a deadline - the pressure to just write the code is real, and having a tool that won't let you is a surprisingly effective forcing function.

For PMs

The spec is complete but what ships is subtly different - missing an edge case, handling one AC differently than intended. pm-refine forces edge cases and acceptance criteria to be explicit before dev starts. The Jira handoff writes your spec into the ticket directly, so the developer reads what you wrote - not a summary someone typed from memory two days later.


Multi-lens code review (new in v3.0.0)

Every code review runs three specialized lenses in parallel, then consolidates findings with deduplication and ranking.

graph LR
    A["Your PR diff"] --> B["Security Lens\nauth, secrets,\ninput validation"]
    A --> C["Engineering Lens\nSOLID, naming,\ncoupling, YAGNI"]
    A --> D["Test Lens\ncoverage gaps,\nfailure paths"]
    B --> E["Consolidation\ndedup + rank"]
    C --> E
    D --> E
    E --> F["Ranked findings\nBlocking / Advisory / Observation"]

Finding severity levels:

  • Blocking - must fix before merge (security vulnerabilities, missing test coverage for critical paths, API contract violations)
  • Advisory - should fix in this PR or immediately after (naming, coupling issues, missing edge case tests)
  • Observation - worth knowing, no action required now

Round 2+ etiquette: on subsequent review rounds, lenses only raise new or worsened findings. If a finding was raised in round 1 and the author chose not to act on it, lenses do not relitigate it. This keeps review cycles from becoming arguments.


Quick start

# Works with Claude Code, Cursor, GitHub Copilot CLI, Gemini CLI, OpenCode, and more
npx skills add badrusiddique/enggenie-skill

Expected output:

Detecting installed AI coding tools...
  ✓ Claude Code detected
  ✓ Cursor detected

Installing enggenie-skill (14 skills)...
  ✓ pm-refine
  ✓ dev-brainstorm
  ✓ dev-plan
  ✓ dev-implement
  ✓ dev-tdd
  ✓ dev-debug
  ✓ review-code
  ✓ review-design
  ✓ qa-verify
  ✓ qa-test
  ✓ dev-commit
  ✓ deploy-ship
  ✓ memory-recall
  ✓ enggenie (gateway)

Installed to: ~/.claude/skills/enggenie/  (Claude Code)
              ~/.cursor/skills/enggenie/   (Cursor)

Done. Skills activate automatically based on your intent.

Claude Code native (no Node.js required):

/plugin marketplace add badrusiddique/enggenie-skill
/plugin install enggenie@badrusiddique-enggenie-skill
/reload-plugins

For platform-specific guides, see:


What makes enggenie different

Generic AI promptingenggenie
Code reviewOne response, one perspective3 parallel lenses: security, engineering, test
TestingWrites tests if you askRefuses to write code without a failing test first
Completion claims"Tests should pass"Requires actual exit codes and test counts as proof
Context between sessionsStarts fresh every timeJira handoff bridges PM to Dev to QA
DebuggingGuesses until it works4-phase investigation: observe, pattern, hypothesis, fix
Estimation"This should take a few days"T-shirt sizing with explicit complexity reasoning
PlatformOne toolClaude Code, Cursor, Copilot CLI, Gemini CLI, OpenCode

Cross-session handoffs via Jira (optional - requires Atlassian MCP)

When different people handle different phases, the Jira ticket becomes the context bridge between roles:

PM runs pm-refine
  → Writes "For Dev" and "For QA" sections to the Jira ticket

Dev picks up the ticket
  → Reads PM's handoff context, builds the feature
  → Writes "Dev Handoff" comment (PR link, what was built, QA focus areas)

QA picks up the ticket
  → Reads PM's "For QA" + Dev's "Dev Handoff"
  → Writes "QA Results" comment (pass/fail, bugs found, coverage)

Any skill can be picked up cold - just reference the Jira ticket and enggenie reads the full chain of context from previous roles. When Jira MCP is not available, handoff context saves to spec files instead.


Real-world scenarios

ScenarioWhat You SaySkill That Activates
PM drops a vague feature request"Write a spec for heist session timer"pm-refine
Choosing between approaches"Server-side vs client-side timer - tradeoffs?"dev-brainstorm
Sprint planning breakdown"Create an implementation plan from this spec"dev-plan
Writing new code from scratch"Add a validateSessionCode function"dev-tdd
Executing a plan"Execute Phase 1 of the implementation plan"dev-implement
Test failure investigation"This Firebase listener is firing twice"dev-debug
Pre-PR review"Review my changes before I push"review-code
Checking implementation vs Figma"Does this match the design?"review-design
Pre-PR sanity check"Are we done? Prove it."qa-verify
Playwright automation"Test the session join flow"qa-test
Committing staged changes"Commit this"dev-commit
Creating a PR"Create a PR for this branch"deploy-ship
Recalling past decisions"What pattern did we use for auth tokens?"memory-recall
Don't know where to start"I need to work on PROJ-1234"enggenie (gateway)

Documentation


Plugin discovery

DirectoryPlatformsURL
skills.shAll (18+ tools)skills.sh
ClaudePluginHubClaude Codeclaudepluginhub.com
Gemini Extensions GalleryGemini CLIgeminicli.com/extensions
Cursor MarketplaceCursorcursor.com/marketplace
SkillsMPAllskillsmp.com

Contributing

See CONTRIBUTING.md. We welcome contributions - especially new reference docs, platform adapters, and bug reports.

License

MIT


Built by Badru Siddique.

Ver o original no GitHub

Bom para

Relacionados