Gangsta Agents (GitHub), a skills framework for spec-driven AI development. I wanted to share it here because the community actually cares about the problem it solves.

---

Why a Mafia family, not an Agile team

A lot of SDD frameworks organize agents to mimic Agile teams — standups, sprints, backlogs, story points. I think that's the wrong metaphor. Agile was designed around human coordination costs. AI agents don't need standups. They need hierarchy, discipline, and enforced pipelines.

Gangsta Agents is inspired by the structure of a Mafia family. There's a Don (you) at the top who approves every phase gate. An Underboss decomposes work. Crew Leads orchestrate. Workers execute in parallel. No one freelances outside their role. No one skips a step.

A well-run Mob moves faster than a committee — and so do agents when you stop pretending they need Agile rituals.

---

The core idea

Every feature goes through a 6-phase pipeline called The Heist:

1. Reconnaissance — gather intel before any design decisions
2. The Grilling — adversarial debate (more on this below)
3. The Sit-Down — produce a signed Contract spec; no code without one
4. Resource Development — execution planning
5. Execution (The Hit) — code runs against the spec, never the other way around
6. The Delivery — wrap up and update institutional memory

Each phase is gated. The Don (you) approves before anything moves forward.

---

What makes it different — The Grilling

Most spec-driven frameworks get you to write a spec before coding. Gangsta Agents adds a step most frameworks skip: adversarial validation before the spec is finalized.

The Grilling runs two agents in structured debate — a Proposer argues for the best approach from the Dossier, a Devil's Advocate attacks every assumption, identifies edge cases, and proposes alternatives. Multiple rounds run until positions stabilize, then the Grilling Conclusions are documented and approved before you ever write a Contract.

The result: weak assumptions get caught through debate, not production failures. I've found this is where single-perspective design silently goes wrong — no one challenges the obvious approach until it's too late.

---

What makes it different — The Ledger

AI sessions are stateless. Every session starts from zero unless you do something about it. Most frameworks don't.

The Ledger is persistent institutional memory stored in docs/gangsta/ in your project. It tracks:

• Insights — successful patterns worth reusing
• Fails — documented mistakes and why they happened
• Constitution — project-specific rules that accumulate over time

The Ledger is updated at the end of every Heist. Any new session can read it and pick up where the last one left off — the agent knows the codebase's quirks, the gotchas, and the agreed-upon rules without you re-explaining them.

Without this, every session re-discovers the same things. Insights don't compound. Fails repeat.

---

Who it supports

Native integrations for Claude Code, GitHub Copilot, Gemini CLI, OpenCode, and Codex. Cursor supported via npx skills add. Skills are pure markdown files — no vendor lock-in, any agent can read them.

---

Happy to answer questions about the design decisions. The spec-is-law principle (Omerta rule #5: code contradicts spec → revise the spec first, never the reverse) was the hardest constraint to enforce in practice, and The Grilling emerged directly from watching LLMs confidently pick the wrong approach with no one to push back.

🔗 https://gangsta.page 🐙 https://github.com/kucherenko/gangsta

Hi everyone! 👋

I'm fairly new here, so I hope this kind of post is okay - please let me know if there's a better place for it.

I wanted to share that jscpd v4.2.0 now includes a completely rewritten Vue support 🎉

One of the biggest improvements is cross-format duplication detection for Vue Single File Components.
This means code inside .vue files can now be checked for duplication against:

• JavaScript / TypeScript
• CSS / SCSS
• and other supported formats

So if the same logic or styles appear across Vue components and regular source files, jscpd can now detect it correctly.

The goal was to make duplication detection much more useful for real-world Vue projects where logic, templates, and styles are often mixed together.

Changelog: https://github.com/kucherenko/jscpd/blob/master/CHANGELOG.md

Feedback and suggestions are very welcome 🙂