juspay

@juspay source repo

75 skills
0 followers
14 hours ago last updated

▌
Nix Justfile · juspay
Conventions for writing justfile recipes in Nix-based projects.

0
installs
▌
Nix Typescript · juspay
pnpm + Nix build conventions. Covers fetchPnpmDeps hash management and dependency workflow.

0
installs
▌
Ralph · juspay
Iterative measurement-driven improvement loop. Measure, profile, mutate, re-measure, commit. Works for performance, bundle size, complexity, test coverage — anything quantifiable. Use when the user wants to systematically improve a metric through repeated cycles of profiling and targeted changes.

0
installs
▌
Elegance · juspay
Iteratively study and apply elegant coding patterns. Each iteration - understand the code, research what simple and elegant code looks like, apply learnings, verify with CI. Use as a standalone refactoring pass or when the user asks to make code more elegant, simple, or idiomatic.

0
installs
▌
Fact Check · juspay
Audit code for correctness and rigor — logic errors, silent error swallowing, wishful thinking, and unjustified fallbacks. This is not a style review; it's a logic review. Use when you want a focused correctness audit separate from the full code-police pass.

0
installs
▌
Forge Pr · juspay bundle
Write engaging PR titles and descriptions for any forge (GitHub today; Bitbucket planned). Use when creating or updating PRs. Leads with narrative paragraphs and reaches for lists, tables, and diagrams when content is genuinely structured.

0
installs
▌
Superposition · juspay bundle
Local codebase analysis for docs

0
installs
▌
Raise Pr · juspay
End-to-end PR workflow for the hyperswitch-control-center repo. Use this skill whenever the user wants to raise a PR, submit changes, open a pull request, commit and push, or ship their work. Triggers on phrases like "raise a PR", "open a PR", "submit my changes", "commit and push", "ship this", "create a pull request". Even if the user just says "PR please" or "push my changes", use this skill.

0
installs
▌
Pr Review · juspay
Review a GitHub PR by fetching its diff, analyzing it with momus (expert reviewer), and producing structured inline comments with file paths, line numbers, and severity levels. MUST USE when the user shares a GitHub PR link and asks for a review, says "review this PR", "look at this pull request", "give me feedback on PR

0
installs
▌
Playwright Test · juspay bundle
Entry point for Playwright test automation. ALWAYS delegates to orchestrator.md. The orchestrator (YOU) detects execution mode (full pipeline or heal-only) and manages the complete workflow including setup, execution, summary, bug reports, and cleanup. Triggers on phrases like "generate tests", "create tests", "run tests", "test flow", "end-to-end test", "e2e test", "test PR", "test module", "test scenario", "analyze for testing", "generate test cases", "write test code", "create test file", "heal tests", "fix failing tests", "debug tests", "repair tests".

0
installs
▌
Neurolink Guide · juspay bundle
Guide for using the NeuroLink SDK and CLI. Invoke when users ask how to use neurolink, integrate AI providers, add MCP tools, configure RAG, set up memory, deploy servers, or work with multimodal content. Covers SDK, CLI, providers, tools, and enterprise features.

0
installs
▌
Repo Conventions · juspay
NeuroLink's review standards — the critical rules to enforce, what NOT to comment on, the security bar, hot paths. Load before reviewing any change in this repository.

0
installs
▌
Github Commenting · juspay
How to post clean, rich, deduplicated GitHub PR review comments — suggestion blocks, multi-line anchors, markers, formatting rules. Load before posting or fixing any PR comment.

0
installs
▌
Haskell · juspay bundle
Use this when writing or reviewing Haskell code. Covers error handling, type safety, idiomatic patterns, HLint compliance, Aeson usage, and testing.

0
installs
▌
Vira Design · juspay
Vira's design system — TailwindCSS conventions, color palette, typography, spacing, components, and accessibility rules. Use when working on UI components, styling, or layout in this project (Lucid HTML in Haskell sources under packages/vira).

0
installs
▌
Jp Prd · juspay bundle
Create, update, or validate a Juspay payment-integration PRD. Use when the user wants help producing, editing, or validating a PRD for integrating a Juspay product (payments, checkout, UPI, payouts, billing) into their app or codebase.

0
installs
▌
Jp Executor · juspay bundle
Implement a Juspay payment integration in the codebase from a jp-prd PRD and a jp-architecture design + task-checklist. Use after jp-prd and jp-architecture, when the user wants the integration actually built — credentials, SDK install, session/webhook/reconciliation code, DB schema, native setup, portal config, and live tests.

0
installs
▌
Jp Validate · juspay bundle
Test/validate a Juspay payment integration after jp-executor has built it. Detects the repo's existing test stack and replicates it (Playwright, Cypress, Jest, Vitest, pytest, supertest, …), falling back to inline curl/bash when none exists. Risk-prioritized coverage of order/session creation, server-to-server status reconciliation, webhook signature + idempotency, per-method process payloads, constraint boundaries and error-code paths — backend and frontend/SDK as the built surface dictates. Ends with a traceability matrix, a PASS/CONCERNS/FAIL quality gate, and a written test report. Use after jp-executor, or standalone against an already-built integration.

0
installs
▌
Jp Architecture · juspay bundle
Design the architecture for a Juspay payment integration — collaborative, step-by-step decisions that ground the integration in real Juspay docs and produce a consistent implementation guide. Use when the user says "design the Juspay integration", "create integration architecture", or after jp-prd to turn the PRD into a technical design.

0
installs
▌
CI · juspay
Reference for the `justci` runner — how to invoke a full pipeline, a single recipe, or a platform-pinned node from a project that depends on `juspay/justci`. Trigger when the user asks to "run justci", "run the pipeline", "re-run a check", or names a specific recipe by `<recipe>@<platform>`.

0
installs
▌
Talk · juspay
Enter talk mode — conversation and research, no repo changes. ONLY invoke when the user explicitly types `/talk` or `$talk`; never auto-select from a natural-language question or design discussion.

0
installs
▌
Hickey · juspay bundle
Evaluate code (especially LLM-generated) for structural simplicity using Rich Hickey's "Simple Made Easy" framework. Use this skill whenever reviewing a PR, diff, or code snippet for accidental complexity — particularly when the code was generated by an AI coding assistant and line-by-line review isn't feasible. Also use when the user asks about complecting, simplicity vs. easiness, structural coupling, or concept deduplication. Trigger on phrases like "is this simple", "does this complect", "review for complexity", "structural analysis", or any reference to Hickey, Simple Made Easy, or grey-box review.

0
installs
▌
Agency Setup · juspay
Bootstrap or update srid/agency in this project — run apm via uvx, configure apm.yml, install skills, draft workflow instructions. Use for first-time setup or to refresh an existing install.

0
installs
▌
Vhs · juspay
Techniques for creating deterministic terminal demo screencasts with VHS

0
installs
▌
Nix CI · juspay
Use this when setting up CI for a GitHub repository — offers GitHub Actions or Vira depending on the project

0
installs
▌
Nix Flake · juspay
Use this when writing or editing a flake.nix. Covers flake-parts, perSystem, formatter, shell scripts, and package conventions.

0
installs
▌
Nix Health · juspay
Use this when diagnosing or fixing a user's Nix installation — checks flakes, version, caches, max-jobs, direnv, rosetta, trusted-users, and shell config

0
installs
▌
Cargo Watch · juspay
Run cargo-watch in the background for continuous clippy feedback during code editing.

0
installs
▌
Nix Haskell · juspay
Use this when working on a Haskell project with Nix. Covers haskell-flake setup, adding/overriding dependencies, package settings, and devShell configuration.

0
installs
▌
Nix Rust Leptos · juspay
Conventions for building Leptos CSR apps with Nix (crane + Trunk).

0
installs
▌
Programming Essay · juspay
Write a programming essay or blog post in the voice of the canon — Spolsky, Yegge, Graham, Mickens, Dijkstra, Brooks, Nystrom, Kleppmann, patio11. Invoke when the user wants to argue an idea about software, architecture, languages, or the craft — not a debugging war story (use debugging-story for that), not a tutorial, not a release note. The audience is working developers worldwide with taste and strong opinions of their own.

0
installs
▌
Pr Reviewer · juspay
Reviews pull requests in the hyperswitch-prism (UCS) Rust codebase using a strict, fail-closed, scenario-aware review system. Classifies PRs into connector, core-flow, proto, server, SDK, CI/security, and GRACE-generated scenarios, then dispatches specialist subagents per scenario. Use when reviewing any PR, batch-reviewing open GRACE PRs, or re-reviewing after author updates.

0
installs
▌
New Connector · juspay bundle
Implements a new payment connector from scratch in the connector-service (UCS) Rust codebase. Creates connector foundation and implements all 6 core payment flows (Authorize, PSync, Capture, Refund, RSync, Void). Use when integrating a new payment gateway that does not yet exist. Requires a technical specification at grace/rulesbook/codegen/references/{connector_name}/technical_specification.md.

0
installs
▌
Coverage Report · juspay bundle
Use when generating connector coverage or capability metrics for meetings, manager/stakeholder updates, retrospectives, or "what changed" / month-over-month / since-release comparisons in the hyperswitch-prism (UCS) repo. Covers coverage diffs over a time window, current-state snapshots, merged-PR activity summaries, and per-connector / per-flow drilldowns. Triggers: "data for the meeting", "how much did coverage change last month", "what did we ship", "supported vs last release".

0
installs
▌
Sdk Integration · juspay bundle
Helps developers integrate with the Hyperswitch Prism SDK across different programming languages and payment scenarios. Provides skills for setting up payment clients, processing payments, handling errors, routing between connectors, configuring connectors, and processing refunds. Supports Python, Node.js, Java/Kotlin, and Rust SDKs.

0
installs
▌
Demo Integration · juspay
Embeds prism into any app and enables to connect to any payment processor

0
installs
▌
Add Connector Flow · juspay bundle
Adds one or more payment flows (Authorize, Capture, Refund, Void, PSync, RSync, webhooks, etc.) to an existing connector in the connector-service (UCS) Rust codebase. Use when a connector already exists but is missing specific flow implementations. Handles dependency validation and sequential implementation order.

0
installs
▌
Add Payment Method · juspay bundle
Adds payment method support (Card, Wallet, Bank Transfer, UPI, BNPL, etc.) to an existing connector in the connector-service (UCS) Rust codebase. Modifies the Authorize flow transformers to handle new payment method data types. Use when a connector exists with Authorize flow but needs to support additional payment methods.

0
installs
▌
Generate Tech Spec · juspay bundle
Generates a technical specification for a payment connector in two phases: (1) discover and verify the connector's official API documentation links, (2) feed those links into the grace techspec CLI to produce a structured spec. Each phase can be delegated to a subagent. Use before implementing a new connector with the new-connector skill.

0
installs
▌
Odu · juspay bundle
Drive CI with `odu` — one shared service, reached from a terminal (`odu surface`), from an agent (`odu mcp`), or from a browser. Trigger when the user asks to "run CI", "run the pipeline", "re-run a check", to run named lanes or recipes (e.g. "run fmt and nix", "just the e2e lane", bare selectors like `fmt`/`nix`/`e2e`), or names a recipe by `<recipe>@<platform>`. This skill — not a repo's local `just ci` / `just <recipe>` — is how an odu-run request is served, whichever face you are on.

0
installs
▌
Be · juspay
Modern, interactive alternative to `/do` — clarify intent up front, then take a task end-to-end with a serial AI review gauntlet (lens review (lowy ∥ hickey) → agent debate → simplify → code-police, each editing the branch in turn) → CI → evidence. ONLY invoke when the user explicitly types `/be` or `$be`; never auto-select from a natural-language request.

0
installs
▌
Do · juspay bundle
Do a task end-to-end — implement, PR, CI loop, ship. ONLY invoke when the user explicitly types `/do` or `$do`; never auto-select from a natural-language request, even one that sounds like an end-to-end task.

0
installs
▌
Pu · juspay
Provision and drive a `pu` box — an Incus container used as a clean Linux host for CI, builds, and evidence capture. Use when you need to run something on a fresh remote box instead of the user's machine: `nix run` a build, run CI against a real host, capture screenshots/video off-machine, or reproduce on a pristine environment. Covers create/connect/scp/destroy, running remote commands, copying artifacts back, and the no-egress failure mode. Triggers on "pu box", "spin up a box", "run this on a box", "ephemeral host", "pu create/connect/destroy".

0
installs
▌
Kolu · juspay bundle
Drive one AI agent from another through kolu's terminals: spawn a Claude Code / Codex / opencode session in a PTY, prompt it, watch the screen for its reply, read it, and prompt again. PRIMARY PATH: the kolu MCP server's tools (`lifecycle_create`/`lifecycle_sendInput` with named keys, the `wait_outputSettled`/`wait_agentState` done-signals, `screen_text`, the `terminals` resource) — configured in this repo's .mcp.json as `kolu mcp`. FALLBACK when the MCP is unavailable: the `kaval-tui`/`padi-tui` CLIs, same verbs, same discipline. Triggers on "drive another agent", "send a prompt to a terminal agent", "have one agent prompt another", "agent drives agent", "orchestrate agents in terminals", "make Claude drive Codex", "prompt the agent running in that terminal", or wiring a loop where one coding agent supervises another.

0
installs
▌
Lowy · juspay
Evaluate architecture and module boundaries for volatility-based decomposition using Juval Lowy's framework (from "Righting Software", building on Parnas 1972). Use when reviewing module splits, service boundaries, new abstractions, or any decomposition decision. Trigger on phrases like "where should this boundary be", "how to split this", "module boundaries", "encapsulate change", "volatility", or references to Lowy, Parnas, or "Righting Software". Complements /hickey (interleaved concerns) with a different lens (change encapsulation).

0
installs
▌
Bridge · juspay bundle
Running memory of the bridge — the coordination rules for a supervising agent driving implementing agents on kolu terminals — authorization boundaries, the dispatch protocol (MCP-first via the kolu skill, with its TUI fallback), verification discipline, and how to communicate with the human. Load whenever coordinating a multi-agent campaign (dispatching briefs to agents in kolu PTYs, tracking their PRs, verifying their claims), or when acting as the coordinator in a padi/surface-style campaign. Triggers on "/bridge", "orchestrate the agents", "coordinate the campaign", "dispatch to the agents", "act as coordinator", or driving multiple implementing agents from one supervising session.

0
installs
▌
Surface · juspay
How a downstream app consumes the shared @kolu/surface stack (@kolu/surface · surface-app · surface-remote · surface-mcp) — declaring a typed reactive surface, serving it, consuming it (SolidJS hooks or a CLI), and mirroring a remote surface over ssh. Grounded in the real consumers: kolu, drishti, odu, and the TUIs. Load when wiring a surface server/client/mirror, or reaching for makeSession / a link / the `.use()` hooks. CHANGING the framework is gated separately — `.claude/rules/surface.md` (a paired, CI-green drishti PR pinned to final kolu HEAD).

0
installs
▌
Diataxis · juspay
Classify, write, and audit documentation per Diátaxis (diataxis.fr) — the four-quadrant method (tutorials · how-to guides · reference · explanation). Encodes the compass as a decision procedure, each quadrant's contract as hard rules, and an executable mixed-mode audit. Project-agnostic; per-repo doc-location mapping lives in .agency/diataxis.md. Use when writing any user-facing doc, structuring a docs site, or auditing existing docs for mixed modes.

0
installs
▌
Be Review · juspay bundle
Run /be's review gauntlet SERIALLY — architecture-first-principles FIRST (framework/structure diffs), then /lens-debate (lowy ∥ hickey), then /agent-debate with an explicitly selected Claude/Codex/Grok peer, then /simplify, then code-police, each editing and committing on the live branch in turn. Use from /be §4, or when the user asks to "run the review gauntlet".

0
installs
▌
Code Police · juspay
Review code for quality, simplicity, and common mistakes before declaring work complete.

0
installs
▌
Coordinator · juspay
Supervise an implementing agent driving a /be run in a kolu terminal: brief it, wire the backchannel, set the goal. Use when one agent session dispatches a task to another agent ("coordinate this", "have Grok/Codex implement X via /be", "supervise the run") — the three moves that keep the run alive without babysitting it.

0
installs
▌
Lens Debate · juspay bundle
Lowy ∥ Hickey lens review

0
installs
▌
Agent Debate · juspay bundle
Run an automated debate with a live Claude, Codex, or Grok peer until consensus — no round cap, no deadlock exit. Two explicit subcommands: `review` has the selected peer critique the current diff while the invoking agent fixes or disputes findings, committing the trail and optionally posting it to the PR; `answer` has both agents independently answer a prompt, cross-check, and return one confirmed answer. The peer runs in a split terminal driven through /kolu. Use when the user types `/agent-debate`, asks Claude/Codex/Grok to review a change, asks two agents to argue until they agree, or wants a consensus answer from two agents.

0
installs
▌
Hostility Review · juspay
Audit an implementation against its plan with a hostile peer agent, debate findings to consensus, and drive fix waves until the auditor runs dry. Use when a done-claim needs verification the implementer cannot game ("hostile review", "adversarial audit", "is this PR faithful", "find the escape hatches") — the loop that beats the laziness bias with its own game theory.

0
installs
▌
Perfection Review · juspay
Adversarial "perfection" review — hold a change to an *ideal* bar, not just a correct one, assuming eternal time, unlimited energy, and no ship pressure. Use when the user asks to review "for perfection", to make a defect "impossible to express", or to hunt where a defect "relocates" across review rounds. Grounds every claim in the diff, fans out adversarial verifiers via Workflow, and reports residual surfaces with a structural fix for each. ONLY invoke when the user explicitly asks for a perfection / ideal-bar review.

0
installs
▌
Architecture First Principles · juspay
Architecture from first principles — the lens, and its executable checks

0
installs
▌
Run · juspay
Run a Xyne Claw agent.

0
installs
▌
Login · juspay
Log the user into Xyne Claw.

0
installs
▌
Ticket Specs · juspay
Create, regenerate, update, and review Xyne Spaces ticket Specifications by interviewing for requirement intent before drafting or writing the Specification.

0
installs
▌
Agents · juspay
List available Xyne Claw agents.

0
installs
▌
Whoami · juspay
Show current Xyne Claw auth identity.

0
installs
▌
Sessions · juspay
List Xyne Claw sessions.

0
installs
▌
Design Brief · juspay
Turn a product or visual request into a concrete interface brief, content hierarchy, user journey, and acceptance checklist before implementing a Design Studio artifact.

0
installs
▌
Design System · juspay
Create or modify coherent visual tokens and reusable component rules for color, typography, spacing, radius, elevation, controls, and interaction states.

0
installs
▌
Dashboard Data · juspay
Build truthful self-contained dashboard snapshots from connected MCP/data tools or user-provided datasets. Use for /dashboard runs that query real metrics, render charts or operational summaries, and may be refreshed by scheduled jobs.

0
installs
▌
React Artifact · juspay
Author app-like designs in React/JSX and bundle them in-sandbox into the same single self-contained HTML artifact Design Studio delivers. Use when the design needs real state, complex interactivity, or component reuse beyond what vanilla JS comfortably handles.

0
installs
▌
Design Critique · juspay
Critique and polish an existing interface by finding hierarchy, consistency, usability, content, accessibility, and visual-quality defects before delivery.

0
installs
▌
Data Visualization · juspay
Design truthful, readable charts, diagrams, dashboards, and metric displays with appropriate encodings, hierarchy, annotation, and responsive behavior.

0
installs
▌
Motion Interaction · juspay
Add purposeful interaction and motion to HTML designs, including state transitions, feedback, navigation, disclosure, and reduced-motion behavior.

0
installs
▌
Browser QA Delivery · juspay
Validate a Design Studio HTML artifact in the sandbox browser, fix rendering and runtime defects, then deliver exactly the tested file.

0
installs
▌
Frontend Composition · juspay
Implement polished self-contained HTML interfaces with semantic structure, maintainable CSS, realistic content, and purposeful visual hierarchy.

0
installs
▌
Responsive Accessibility · juspay
Make Design Studio artifacts responsive, keyboard operable, semantically correct, and readable across common viewport and input conditions.

0
installs
▌
Evidence Citations · juspay
Anchor every claim in an explanation to file:line evidence you actually opened, and mark the difference between what you verified and what you inferred.

0
installs
▌
Explanation Document · juspay
Structure a codebase/schema explanation as a self-contained HTML document ordered for a READER — mental model and flows first, deep per-component reference last — not in the order you explored it.

0
installs
▌
Architecture Diagrams · juspay
Author architecture, ER, and flow diagrams as hand-written inline SVG inside a self-contained HTML page — no mermaid, no scripts, no CDN.

0
installs

75 published skills