Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    fullstackdev for iot

    0

    Senior full-stack engineer for building end-to-end features, schemas, and APIs with TypeScript and Next.js.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    fullstackdev for iot

    fullstackdev for iot

    Example session with this skill installed

    Build a simple bookmarking feature where authenticated users can save URLs with a title.

    • Read your context and instructions
    • Compiled the fullstackdev for iot

    I have designed and implemented the full-stack bookmarking feature. This includes the database schema, a Zod-validated server action for saving data, and a React component with loading states.

    Feature Implementation

    1. Database Schema (Prisma)

    model Bookmark {
      id        String   @id @default(uuid())
      url       String
      title     String
      userId    String
      createdAt DateTime @default(now())
    }
    

    2. Backend Logic (Next.js Server Action)

    "use server";
    import { z } from "zod";
    import { db } from "@/lib/db";
    import { auth } from "@/lib/auth";
    
    const BookmarkSchema = z.object({
      url: z.string().url(),
      title: z.string().min(1).max(100),
    });
    
    export async function createBookmark(formData: z.infer<typeof BookmarkSchema>) {
      const session = await auth();
      if (!session) throw new Error("Unauthorized");
    
      const { url, title } = BookmarkSchema.parse(formData);
    
      return await db.bookmark.create({
        data: { url, title, userId: session.user.id },
      });
    }
    

    3. Frontend Component (React + Tailwind)

    import { useState } from "react";
    import { createBookmark } from "@/actions/bookmarks";
    
    export function BookmarkForm() {
      const [loading, setLoading] = useState(false);
    
      async function handleSubmit(e: React.FormEvent<HTMLFormElement>) {
        e.preventDefault();
        setLoading(true);
        // Implementation logic here...
        setLoading(false);
      }
    
      return (
        <form onSubmit={handleSubmit} className="space-y-4 p-4 border rounded-lg">
          <input name="title" placeholder="Title" className="w-full border p-2" required />
          <input name="url" placeholder="https://..." className="w-full border p-2" required />
          <button disabled={loading} className="bg-blue-500 text-white px-4 py-2 rounded">
            {loading ? "Saving..." : "Save Bookmark"}
          </button>
        </form>
      );
    }
    

    Next steps

    • Run npx prisma migrate dev to update your database.
    • Integrate the BookmarkForm into your protected dashboard route.
    • Add a list component to fetch and display saved bookmarks using React Query.

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

    About this skill

    Fragmented development slows down shipping. This skill bridges the gap between frontend, backend, and database logic, providing production-ready code for end-to-end features. It ensures architectural consistency by enforcing clean separation of concerns and modern type safety across the entire application.

    What it does

    • Schema Design defines database models and ORM structures using Prisma or Drizzle.
    • API Development builds RESTful or GraphQL endpoints with strict input validation and error handling.
    • Frontend Implementation generates React components using Next.js, Tailwind CSS, and state management libraries.
    • Security Auditing implements JWT/Auth flows and ensures OWASP compliance for data handling.
    • Type Safety enforces TypeScript across the stack to prevent runtime errors between client and server.

    How it works

    1. Model Definition starts by establishing the database schema and data relationships.
    2. Logic Layering builds out backend handlers, server actions, and business logic.
    3. UI Construction develops the frontend components with integrated state and data fetching.
    4. Security Hardening applies validation via Zod and checks for sensitive data leaks.

    Frameworks & tools

    Optimized for Next.js (App Router), React, TypeScript, and Tailwind CSS. Supports PostgreSQL with Prisma/Drizzle, React Query, Zustand, and standard Auth providers.

    Why this beats prompting it yourself

    Generic prompts often result in disjointed code that fails at the integration layer. This skill forces a "schema-first" approach that ensures the frontend and backend actually talk to each other correctly.

    Use cases

    • Scaffold a new full-stack feature from a single requirement.
    • Migrate a plain JavaScript stack to a type-safe TypeScript architecture.
    • Build secure authentication and authorization flows with validated inputs.
    • Resolve performance bottlenecks or architectural debt in existing applications.

    Known limitations

    Focuses primarily on the Next.js and Node.js ecosystem. It does not provide mobile-specific code or low-level systems programming.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Frontend & Web Apps.

    Primary focus on Node.js/Next.js/TypeScript stack. Does not support legacy PHP, Ruby on Rails, or mobile-native environments.

    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 25 days ago

    Permissions

    No special permissions declared or detected

    Listed25 days ago
    Updated22 days ago

    What's inside

    Frequently Asked Questions

    The fullstackdev skill is designed for any AI agent that supports code generation and execution, specifically those optimized for the TypeScript and Next.js ecosystem. It functions as a specialized logic layer that enhances an agent's ability to handle complex, multi-file architectural tasks.

    Unlike standard prompts that might generate isolated snippets, this skill enforces a 'schema-first' methodology. It ensures that database models, API routes, and React components are perfectly synced via TypeScript, preventing the common integration errors found in fragmented code generation.

    This skill is specifically optimized for the modern T3-style stack, including Next.js (App Router), Tailwind CSS, TypeScript, and ORMs like Prisma or Drizzle. While it can adapt to other Node.js environments, it is most effective when building within these specific frameworks.

    The skill includes a comprehensive set of logic patterns and architectural constraints that guide your agent through the full development lifecycle. You receive the specialized capabilities to design schemas, build secure APIs, and generate type-safe UIs as outlined in the skill description.

    Yes, once the skill is integrated into your agent's workflow, you can provide an existing codebase. The skill will analyze your current architecture to suggest and implement type-safe migrations, performance optimizations, or new feature additions that align with your current patterns.

    New in Frontend & Web Apps