Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    thinktank

    2

    Evidence-led engineering framework for coding agents featuring multi-role delegation and independent verification.

    $10

    /mo

    Subscription · cancel anytime

    Secure checkout via Stripe

    • Always the latest version
    • Delivered live to your agent via MCP
    • Cancel anytime, access ends at period end
    Security scanned
    thinktank

    thinktank

    Example session with this skill installed

    thinktank implement and verify a new idempotent stripe webhook handler in the backend domain, including retry logic and a failing test case to start.

    • Read your context and instructions
    • Compiled the thinktank

    I have initiated the ThinkTank engineering cycle for the Stripe webhook implementation. The task has been framed, domain contracts have been generated, and the independent checker has been assigned.

    Engineering Verdict: VERIFIED

    PhaseActivityResultEvidence
    FrameDetected Node.js/Express stackgroundedpackage.json line 12
    PlanGenerated thinktank-backend contractvalidscripts/validate-plan.mjs
    ActCreated src/webhooks/stripe.tssuccessGit diff +142 lines
    VerifyExecuted npm test tests/webhooks.spec.tspass4 tests passed, 0 failed
    CheckIndependent Checker rerun of test suiteACCEPTTerminal log run_id: 882f

    Verified Deliverables

    // src/webhooks/stripe.ts
    import { Request, Response } from 'express';
    import db from '../db';
    
    export const handleStripeWebhook = async (req: Request, res: Response) => {
      const event = req.body;
      
      // Idempotency check: Ensure we haven't processed this event ID
      const existingEvent = await db.processedEvents.findUnique({
        where: { id: event.id }
      });
    
      if (existingEvent) {
        return res.status(200).json({ received: true, duplicate: true });
      }
    
      // Domain logic execution...
      await db.$transaction(async (tx) => {
        await tx.processedEvents.create({ data: { id: event.id } });
        // ... update subscription status
      });
    
      return res.status(200).json({ received: true });
    };
    

    Next steps

    1. Review the generated tests/webhooks.spec.ts for edge case coverage.
    2. Approve the PR to merge the verified implementation into the main branch.
    3. Observe the deployment logs for the new idempotency table migration.
    $10/mo

    Subscription · always the latest version

    • Secure checkout via Stripe
    • Cancel anytime
    • Delivered live via MCP

    About this skill

    Large-scale software engineering tasks often fail when agents make trivial edits without verifying the broader system impact. ThinkTank solves this by enforcing evidence-led engineering, requiring executed proof and independent verification for every significant change. It moves beyond simple prompting by framing tasks within the live repository, delegating domain-specific work through read-only contracts, and utilizing a multi-role architecture where the maker never issues their own acceptance verdict.

    What it does

    • Multi-role orchestration splits work between Parent, Prompter, Domain Worker, and Independent Checker roles.
    • Evidence-led verification maintains a ledger of claims, file-line citations, and test outputs for every modification.
    • Cognitive discipline follows a structured cycle of perception, situation modeling, action, and verification.
    • Dynamic stack detection identifies the repository's language and framework to load relevant engineering skills.
    • Safety-gated delivery enforces human-in-the-loop checkpoints for merges, deployments, and high-risk AI touchpoints.

    How it works

    1. Perception and framing starts by reading live files and runtime probes to build a grounded situation model.
    2. Domain delegation uses the Prompter to generate strict, read-only contracts for specific backend, frontend, or security tasks.
    3. Execution and verification runs the implementation within isolated worktrees, followed by automated test rungs.
    4. Independent check passes the final artifact to a separate Checker role that reruns probes to issue a final verdict.

    Frameworks & tools

    This skill integrates with Claude Code (using Agent and Bash tools) and Hermes. It supports optional local Qdrant memory and includes deterministic validation scripts for Node.js.

    Why this beats prompting it yourself

    Standard prompts lack the structural "maker-checker" separation needed for production reliability. ThinkTank prevents regression by freezing acceptance criteria before code is written and requiring external proof that matches the original brief.

    Use cases

    • Complex migrations involving cross-file changes that require verified dependency mapping.
    • Security hardening using dedicated security domain contracts to identify and fix abuse cases.
    • Performance optimization where changes must be backed by simulation evidence and runtime benchmarks.
    • Architectural refactoring that needs isolated worktrees and independent verification of API contracts.

    Known limitations

    Does not support arbitrary shell commands or external network grants without host-specific adapters. Memory features require local Qdrant setup or host-provided tools. Standard loops are limited to three correction rounds.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Requires host-native tools (Bash, Read/Write). Memory requires local Qdrant or host support. Limited to three correction rounds by default. No automatic deployment without human approval.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 27 days ago

    Software
    PlaywrightNode.jsQdrant MCPuv (Python tool runner)Git

    Permissions

    Browser
    Network Access
    Read Files
    Write Files
    Listed27 days ago

    What's inside

    Frequently Asked Questions

    ThinkTank addresses the 'hallucination and break' cycle by implementing a maker-checker architecture, where changes are only accepted if they pass independent verification against pre-frozen criteria.

    ThinkTank is specifically optimized for Claude Code and Hermes, leveraging their tool-calling capabilities to perform live repository probes and bash-based execution.

    You receive the core multi-role orchestration framework, domain-specific contract templates, and deterministic validation scripts for Node.js environments.

    Setup requires providing the agent with file-system access; while memory features are optional, they require a local Qdrant instance if you wish to persist context across long-running engineering sessions.

    ThinkTank is designed for highly controlled environments and restricts arbitrary shell commands, requiring host-specific adapters for any external network grants or high-risk operations.

    New in Agents & Orchestration