- Home
- Skills
- Agents & Orchestration
- Prod-Ready
More screenshots
Works with the AI Agents you already use
Prod-Ready
Enforce 25 production performance rules and an anti-AI-slop design system to eliminate slow, generic AI-generated code.
$5
Prod-Ready
Example session with this skill installed
Create a search component for a user database and the corresponding backend API route using the prod-ready standards.
- Read your context and instructions
- Compiled the prod-ready
I have generated a production-ready search implementation. The frontend uses a 300ms debounce, cancels in-flight requests with AbortController (including on unmount), checks res.ok and shows a skeleton only on the first load. The backend requires authentication, scopes results to the user’s tenant, validates input, and uses stable cursor-based pagination with explicit column projection.
Production Search Implementation
// Frontend: SearchComponent.tsx
import React, { useState, useEffect } from 'react';
type User = { id: string; name: string; avatarUrl: string | null };
export const UserSearch = () => {
const [query, setQuery] = useState('');
const [results, setResults] = useState<User[]>([]);
const [loading, setLoading] = useState(false);
useEffect(() => {
const term = query.trim();
if (term.length < 2) {
setResults([]);
setLoading(false);
return;
}
// Um controller por busca: o cleanup cancela a anterior ao digitar ou desmontar
const controller = new AbortController();
const handler = setTimeout(async () => {
setLoading(true);
try {
const res = await fetch(`/api/users?q=${encodeURIComponent(term)}`, {
signal: controller.signal,
});
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const data: { items: User[] } = await res.json();
setResults(data.items);
} catch (err) {
if ((err as Error).name !== 'AbortError') console.error('Erro na busca', err);
} finally {
if (!controller.signal.aborted) setLoading(false);
}
}, 300);
return () => {
clearTimeout(handler);
controller.abort();
};
}, [query]);
return (
<div className="search-container">
<label htmlFor="user-search" className="sr-only">Buscar usuários</label>
<input
id="user-search"
type="search"
value={query}
onChange={(e) => setQuery(e.target.value)}
className="token-input-primary"
placeholder="Buscar usuários..."
autoComplete="off"
/>
<div aria-busy={loading}>
{loading && results.length === 0 ? <UserSkeletonList /> : <UserList items={results} />}
</div>
</div>
);
};
// Backend: route.ts (Node.js/Prisma)
const PAGE_SIZE = 20;
export async function GET(req: Request) {
const session = await getSession(req); // sua função de autenticação
if (!session) return new Response(null, { status: 401 });
const { searchParams } = new URL(req.url);
const q = (searchParams.get('q') ?? '').trim();
const cursor = searchParams.get('cursor') ?? undefined;
if (q.length < 2 || q.length > 100) {
return Response.json({ items: [], nextCursor: null });
}
const rows = await prisma.user.findMany({
take: PAGE_SIZE + 1, // um a mais para saber se há próxima página
...(cursor && { cursor: { id: cursor }, skip: 1 }),
where: {
tenantId: session.tenantId, // nunca listar usuários de outro cliente
name: { contains: q, mode: 'insensitive' },
},
select: { id: true, name: true, avatarUrl: true },
orderBy: [{ createdAt: 'desc' }, { id: 'desc' }], // desempate estável
});
const hasMore = rows.length > PAGE_SIZE;
const items = hasMore ? rows.slice(0, PAGE_SIZE) : rows;
return Response.json({ items, nextCursor: hasMore ? items[items.length - 1].id : null });
}
Next steps
Indexes.
Add a composite index for the tenant filter and the cursor ordering: @@index([tenantId, createdAt(sort: Desc), id]) in the Prisma schema.
For contains on large tables, a B-tree index on name does not help. Use a trigram GIN index on PostgreSQL (CREATE EXTENSION pg_trgm; CREATE INDEX users_name_trgm ON "User" USING gin (name gin_trgm_ops);) or a FULLTEXT index on MySQL.
CSS. Confirm that token-input-primary and sr-only exist in your stylesheet using the semantic tokens from references/design-system.html. If they don’t, define them there instead of inventing new values.
Rate limiting. Add rate limiting to /api/users, since a search endpoint is called on every pause in typing.
No cache needed. Skip Redis for this route: search terms produce near-unique keys, so the hit rate is low. If you cache any user-dependent route later, the key must include the tenant (e.g. t:{tenantId}:users:search:{hash(q)}), per rule 11.
Connects securely to your tools. The creator never sees your data.
About this skill
Stop shipping slow, generic apps that look like AI templates. Most AI-generated code suffers from "AI-slop": purple gradients, low-contrast text, and single-column layouts paired with unoptimized database queries and blocking operations. This skill enforces 25 strict production-grade engineering parameters and a professional design system to ensure your software is fast, accessible, and scalable from the first line of code.
What it does
- Enforces Production Standards applying 25 mandatory rules for performance, architecture, and database efficiency.
- Eliminates AI-Slop Design by replacing generic AI layouts with a structured design system using semantic tokens and high-contrast typography.
- Optimizes Data Handling through mandatory pagination, explicit column projection, and N+1 query elimination.
- Implements Performance Patterns including Skeleton screens, AbortController debouncing, and optimistic UI updates.
- Architects Scalability by offloading heavy tasks to background queues and implementing Redis caching strategies.
How it works
- Analyze Requirements for any new application, API, or component request to identify performance bottlenecks.
- Apply Architectural Rules such as connection pooling, Brotli compression, and stateless backend design.
- Execute UI Guidelines using the provided design system tokens for accessibility (WCAG AA/AAA) and complex layouts like sidebars and drawers.
- Audit and Refactor existing code to remove unused dependencies and implement code-splitting or list virtualization.
Frameworks & tools
Works with any full-stack environment including React, Next.js, Node.js, Python (Celery/BullMQ), SQL databases (PostgreSQL/Prisma), and Redis.
Why this beats prompting it yourself
Generic prompts often ignore real-world constraints like network latency and cumulative layout shift. This skill bakes in senior-level architectural decisions—like AbortController integration and background job delegation—that require manual, repetitive prompting to achieve otherwise.
Use cases
- Building Dashboards that require list virtualization for thousands of rows and complex sidebar navigation.
- Developing APIs that need strict pagination, caching, and protection against N+1 query performance hits.
- Refactoring Prototypes to replace generic spinners with layout-accurate Skeleton screens and WebP/AVIF image handling.
- Implementing AI Features that require token-by-token streaming via Server-Sent Events rather than buffered responses.
Known limitations
Does not perform live infrastructure provisioning or external API testing. Requires the developer to provide the runtime environment for the generated architectural patterns.
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 manual implementation of infra tools like Redis or BullMQ. Does not perform live network testing or real-time RUM monitoring.
How to use
- 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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 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
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 12 days ago
- Software
Git