More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Web and Backend Stacks

    1

    Deliver front-end, back-end and modern APIs with TypeScript, Python and FastAPI. 10 ordered skills, starting with Full Stack Development, React Front-End Development, Node.js Back-End Development.

    $3

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Web and Backend Stacks

    Web and Backend Stacks

    Example session with this skill installed

    Build a FastAPI endpoint to create a new 'Project'. I need a Pydantic model for input, a response model that hides the owner_id, and it should use a database session dependency.

    • Read your context and instructions
    • Compiled the web and backend

    I have structured the Project creation endpoint with separate input and response models, utilizing a scoped database dependency to ensure resource safety.

    FastAPI Project Endpoint Implementation

    from typing import Annotated
    from fastapi import APIRouter, Depends, HTTPException, status
    from pydantic import BaseModel, Field
    from sqlalchemy.orm import Session
    from .database import get_db
    
    router = APIRouter(prefix="/projects", tags=["projects"])
    
    # Input model: What the client sends
    class ProjectCreate(BaseModel):
        name: str = Field(..., min_length=1, max_length=100)
        description: str | None = Field(None, max_length=500)
    
    # Output model: Filters sensitive data like owner_id
    class ProjectRead(BaseModel):
        id: int
        name: str
        description: str | None
    
        class Config:
            from_attributes = True
    
    # Dependency Alias
    SessionDep = Annotated[Session, Depends(get_db)]
    
    @router.post("/", response_model=ProjectRead, status_code=status.HTTP_201_CREATED)
    def create_project(project_in: ProjectCreate, db: SessionDep):
        """
        Creates a new project record.
        The response_model ensures owner_id and other internal fields are not leaked.
        """
        # Business logic layer (simplified)
        new_project = Project(
            name=project_in.name,
            description=project_in.description,
            owner_id=123 # Hardcoded for example; usually from auth dependency
        )
        db.add(new_project)
        db.commit()
        db.refresh(new_project)
        return new_project
    

    Next steps

    1. Add an Annotated dependency for authentication to replace the hardcoded owner_id.
    2. Implement a GET /{project_id} endpoint using the same ProjectRead model.
    3. Write a test case using TestClient with a dependency override for the database.

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

    About this skill

    The problem

    Full-stack freelancers often need a repeatable process, not a one-off prompt. This pack targets: Deliver front-end, back-end and modern APIs with TypeScript, Python and FastAPI.

    What's inside (10 skills, suggested learning order)

    1. Full Stack Development — Build complete front-end and back-end.
    2. React Front-End Development — Web interfaces with React/Next.js.
    3. Node.js Back-End Development — APIs and services with Node.
    4. Python Back-End Development — APIs and services in Python.
    5. FastAPI — Build high-performance APIs for AI.
    6. TypeScript Development — Static typing for modern apps.
    7. Python Programming for Automation — Scripts and automated tools.
    8. SQL Software Engineering — Modeling and querying relational databases.
    9. AI SQL Code Generation — Generate and optimize queries.
    10. Internal Platform Engineering — Build portals and platforms for developers.

    Why a skill pack instead of a one-off prompt

    Each skill gives the agent a defined trigger, step-by-step procedure and output format, so results are consistent across sessions and easier to review.

    How to use

    1. Install the pack in your SKILL.md-compatible agent.
    2. Ask for the task in plain language (for example: "build complete front-end and back-end").
    3. Review the output against the skill's quality checks before using it.

    Known limitations

    • Outputs are drafts that need human review; they are not professional, legal or financial advice.
    • Tools, APIs and prices change; check current vendor documentation before relying on version-specific details.
    • Quality depends on the context you give the agent (data, requirements, constraints).
    • Tested only where stated in the Compatibility note.

    Also by Rodrigo Santos

    Specialized Agents and Distribution; AI Agents: Fundamentals and Protocols; Model Fine-Tuning and Alignment

    Does not perform framework selection across languages. Not for mobile development. Requires DDL for SQL generation. Scripts assume standard library or common packages like pandas.

    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 any payment.

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

    Permissions

    Read Files
    Listed4 days ago

    What's inside

    Frequently Asked Questions

    This skill provides a structured suite of engineering patterns that enforce production-grade standards, such as type safety, validated API boundaries, and optimized SQL, which generic prompts often overlook or implement insecurely.

    The suite is optimized for modern full-stack environments including React, Next.js, and TypeScript on the frontend, and Node.js (Express/Fastify) or Python (FastAPI/Django/Flask) on the backend with PostgreSQL.

    Upon purchase, you receive a comprehensive collection of specialized sub-skills covering full-stack delivery, backend hardening, SQL modeling, React orchestration, and platform automation templates.

    While it excels at building and optimizing complex backend logic and database schemas, it does not support mobile-native development (iOS/Android) or provide high-fidelity CSS/UI styling polish.

    This skill is designed to integrate with any AI agent that supports custom tool definitions or structured prompt libraries, functioning as a high-level architectural guide for the agent's output.

    Yes, the skill follows a 'contract-first' methodology, meaning it performs best when you provide existing DDL, API schemas, or component prop definitions as a foundation for the implementation.

    New in APIs & Backend