agentleFS
LucfaceLucface/claude-skills/skills/fullstack-agent/SKILL.md

fullstack-agent

Skill1 starsChanged 3 days agoMITView on GitHub

Enables AI agents to create complete web applications with file system operations, code execution, template sandboxes, and live preview through sandbox URL hosting.

1 other project uses a version of this.

Adopted by

Most recently taken up by

The file

We split this skill into the rules it gives an agent

1 rule. About 0 are common, 1 is distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈1

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Review Changes: Check modified files before next prompt

    line 150

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Full Stack Agent Skill

Overview

Full Stack Agents combine:

  • File system operations (read, write, search, replace)
  • Code execution for running build tools, tests
  • Template sandboxes with frameworks pre-installed
  • Live preview through sandbox URL hosting

Quick Start

Setup with Next.js Template

from lib.coding_agent import coding_agent
from lib.tools_schemas import tools_schemas
from lib.tools import tools
from lib.prompts import SYSTEM_PROMPT_WEB_DEV
from lib.ui import ui
from lib.utils import create_sandbox
from openai import OpenAI

# Create sandbox with Next.js pre-installed
sbx = create_sandbox(template="dlai-nextjs-developer")

client = OpenAI()
messages = []

# Launch with UI
demo = ui(
    coding_agent,
    messages,
    host=f"https://{sbx.get_host(3000)}",  # Next.js dev server
    client=client,
    sbx=sbx,
    max_steps=100,
    system=SYSTEM_PROMPT_WEB_DEV,
    tools=tools,
    tools_schemas=tools_schemas,
    model="gpt-4o-mini",
)
demo.launch(share=True, height=800)

Available Tools

Six sandbox tools handle all file system operations:

ToolPurpose
list_directoryExplore project structure
read_fileRead existing files
write_fileCreate or update files (auto-creates directories)
search_file_contentRegex search across files (skips node_modules)
replace_in_fileFind-and-replace text in a file
globFind files by glob pattern (e.g., **/*.tsx)

Each tool accepts a sandbox instance (sbx) and returns a dict with results or {"error": ...}.

See reference/tool-implementations.md for complete Python implementations and JSON schemas.

Tools Dictionary (binding tools to sandbox)

def create_tools(sbx):
    """Create tools bound to a sandbox."""
    return {
        "list_directory": lambda path: list_directory(path, sbx),
        "read_file": lambda file_path: read_file(file_path, sbx),
        "write_file": lambda file_path, content: write_file(file_path, content, sbx),
        "search_file_content": lambda pattern, path=".", limit=20: search_file_content(pattern, path, limit, sbx),
        "replace_in_file": lambda file_path, old_text, new_text: replace_in_file(file_path, old_text, new_text, sbx),
        "glob": lambda pattern: glob_files(pattern, sbx),
    }

tools_schemas = [
    list_directory_schema, read_file_schema, write_file_schema,
    search_file_content_schema, replace_in_file_schema, glob_schema,
]

System Prompts

Two pre-built system prompts are available:

SYSTEM_PROMPT_WEB_DEV

General-purpose Next.js 14+ / React / TypeScript / Tailwind prompt. Instructs the agent to explore before modifying, make incremental changes, and preserve existing code style. Includes Next.js App Router project structure and common patterns (pages, components, API routes).

See reference/system-prompts.md for the complete prompt text and code pattern examples.


Agent Workflow Patterns

The agent follows an explore-then-modify pattern:

  1. Explore -- list_directory and read_file to understand structure
  2. Plan -- Identify which files to create or modify
  3. Execute -- write_file or replace_in_file one file at a time
  4. Verify -- Read modified files, check for errors

Common Scenarios

ScenarioKey Tools Used
Create landing pagelist_directory -> read_file -> write_file (page + components)
Add authenticationlist_directory -> write_file (login page + form component) -> update layout
Modify existing featuresearch_file_content -> read_file -> replace_in_file

See reference/examples.md for detailed step-by-step workflow examples and Gradio UI setup.


Gradio UI Integration

The UI provides chat interface, live preview iframe, token usage stats, and tool execution logs:

demo = ui(
    coding_agent, messages=[],
    host=f"https://{sbx.get_host(3000)}",
    client=client, sbx=sbx, max_steps=100,
    system=SYSTEM_PROMPT_WEB_DEV,
    tools=create_tools(sbx),
    tools_schemas=tools_schemas,
    model="gpt-4o-mini",
)
demo.launch(share=True, height=800)

Tips for Better Results

  1. Set Higher max_steps: Web dev needs more iterations (50-100)
  2. Use Templates: Pre-configured sandboxes save time
  3. Provide Context: Tell the agent about existing patterns
  4. Incremental Requests: Build features step by step
  5. Review Changes: Check modified files before next prompt

Source

Inspired by the DeepLearning.AI course Building Coding Agents with Tool Execution, lesson L6. No canonical public repo was found.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.