Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Full Stack Feature Builder Skill

    1

    Plan, implement, and verify end-to-end features across frontend, backend, and database with strict engineering standards.

    $19

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Full Stack Feature Builder Skill

    Full Stack Feature Builder Skill

    Example session with this skill installed

    Add a 'User Profile' feature to our Next.js/Prisma app. Users need to update their bio and avatar. Include backend validation and a migration for the new bio field.

    • Read your context and instructions
    • Compiled the full stack feature
    • Generated the app files

    I have analyzed the request for the User Profile feature. Below is the implementation report covering the frontend components, API routes, and database schema updates.

    Full-Stack Feature Delivery Report

    1. Feature Summary

    • User problem: Users cannot manage their personal identity within the application.
    • Proposed behavior: Add a profile settings page with a bio text area and avatar URL input.
    • Scope: Database schema update, API endpoint for updates, and React form component.
    • Out of scope: Image file hosting (using URL strings for now), password reset flows.

    2. Repository and Architecture Findings

    • Framework: Next.js (App Router).
    • ORM: Prisma with PostgreSQL.
    • Auth: NextAuth.js session-based patterns detected in /lib/auth.ts.

    3. Acceptance Criteria

    • Bio field supports up to 500 characters.
    • Profile updates are restricted to the authenticated owner.
    • UI displays success toast on save and error message on validation failure.

    4. Implementation Plan

    AreaWork itemDependenciesAcceptance check
    DataAdd bio field to User modelPrisma CLIMigration runs successfully
    APICreate /api/user/profile PUTAuth session401 for guests, 200 for owners
    UIBuild ProfileForm componentZod/Hook FormForm resets on success

    5. Implementation Details

    Data

    Added bio String? @db.Text to the User model in schema.prisma. Created a migration to update the PostgreSQL table.

    API

    Implemented a PUT handler in app/api/user/profile/route.ts. It validates input using Zod and verifies session.user.id matches the target record before calling prisma.user.update.

    Frontend

    Created ProfileForm.tsx using Tailwind CSS. Added states for isPending and error. Used useForm for client-side validation mirroring the server schema.

    6. Verification Results

    CheckStatusCommand or methodResult
    LintingPASSnpm run lintNo errors in new files
    Unit TestPASSnpm test profile-apiCorrectly handles 401s
    MigrationPASSnpx prisma migrate devSchema synced

    7. Risks and Compatibility

    • Migration: Adding a nullable column is backward compatible. No data backfill required.
    • Security: Server-side Zod validation prevents XSS in the bio field.

    8. Delivery and Next Steps

    • Run npx prisma generate to update types.
    • Update NEXTAUTH_SECRET in production env if not already set.
    • Future work: Implement S3 upload for avatars to replace raw URL strings.

    Next steps

    1. Review the generated Prisma migration file in /prisma/migrations.
    2. Test the form with a bio exceeding 500 characters to verify the error state.
    3. Verify the responsive layout on mobile devices.

    ProfileForm.tsx

    ZIP · project files

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Engineering a full-stack feature often results in fragmented code, ignored edge cases, and architectural drift. This skill enforces a verification-driven approach to turn high-level requests into production-ready implementations across the entire stack. It bridges the gap between frontend components, backend services, and data persistence while maintaining strict adherence to existing project conventions.

    What it does

    • Task scoping classifies requests into features, enhancements, or bug fixes while identifying risks and out-of-scope items.
    • Architectural inspection analyzes project structures, package manifests, and existing patterns to ensure consistent implementation.
    • Vertical slice implementation builds end-to-end functionality from UI to database, including loading, success, and error states.
    • Contract design defines API request/response shapes, data entities, validation rules, and permission models.
    • Security hardening enforces server-side authorization, input validation, and sensitive data protection.
    • Verification reporting logs actual test results, lint checks, and accessibility audits using a structured status format.

    How it works

    1. Analyze and scope the feature request to define acceptance criteria and dependencies.
    2. Inspect the codebase to map existing routing, state management, and data access patterns.
    3. Execute the implementation plan across frontend, backend, and data layers in small, verifiable slices.
    4. Run verification using provided toolchains to report PASS, FAIL, or BLOCKED statuses for all changes.

    Frameworks & tools

    Works with any modern full-stack environment including React, Next.js, Vue, Node.js, Python, Go, and SQL/NoSQL databases. It adapts to existing testing suites like Jest, Vitest, or Playwright and follows project-specific linting and formatting rules.

    Why this beats prompting it yourself

    Standard prompting often ignores backend validation or fails to account for existing database schemas, leading to code that looks right but breaks in production. This skill mandates a "measure twice, cut once" workflow that explicitly checks for security vulnerabilities and breaking API changes before finishing.

    Use cases

    • Adding a new authenticated user dashboard with real-time data fetching.
    • Extending an existing REST or GraphQL API with new endpoints and validation logic.
    • Implementing a complex multi-step form with frontend validation and database persistence.
    • Refactoring a legacy service to improve performance without breaking public interfaces.

    Known limitations

    Does not perform live deployments or data migrations unless execution tools are available. Verification is limited to the tests and tools currently configured in the user repository.

    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.

    Cannot perform live deployments. Verification depends on available local toolchains. Does not fabricate repository content if access is missing.

    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

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 16 days ago

    Permissions

    Read Files
    Network Access
    Listed16 days ago

    What's inside

    Frequently Asked Questions

    This skill enforces a verification-driven workflow that builds end-to-end 'vertical slices.' Unlike generic prompts, it explicitly validates API contracts, security permissions, and database constraints to ensure the feature actually works in production.

    The skill is framework-agnostic and adapts to your existing repository. It analyzes your package manifests and file structure to ensure new code matches your specific routing, state management, and styling patterns.

    No, this skill is designed to work within your existing environment. It identifies and utilizes the testing libraries (like Jest or Playwright) and linting tools already configured in your project to verify its own work.

    The skill can plan and implement database schema changes and data access logic, but it does not perform live production migrations. It focuses on the implementation layer, providing the code and logic necessary for your migration tools to execute.

    Each implementation includes a structured Verification Report. This log details the results of lint checks, unit tests, and accessibility audits, giving you a clear PASS/FAIL status for every component of the new feature.

    New in Agents & Orchestration