home / skills / jeremylongshore / claude-code-plugins-plus-skills / replit-local-dev-loop

This skill helps you configure a fast local Replit development loop with hot reload and tested workflows for rapid iteration.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill replit-local-dev-loop

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.9 KB
---
name: replit-local-dev-loop
description: |
  Configure Replit local development with hot reload and testing.
  Use when setting up a development environment, configuring test workflows,
  or establishing a fast iteration cycle with Replit.
  Trigger with phrases like "replit dev setup", "replit local development",
  "replit dev environment", "develop with replit".
allowed-tools: Read, Write, Edit, Bash(npm:*), Bash(pnpm:*), Grep
version: 1.0.0
license: MIT
author: Jeremy Longshore <[email protected]>
---

# Replit Local Dev Loop

## Overview
Set up a fast, reproducible local development workflow for Replit.

## Prerequisites
- Completed `replit-install-auth` setup
- Node.js 18+ with npm/pnpm
- Code editor with TypeScript support
- Git for version control

## Instructions

### Step 1: Create Project Structure
```
my-replit-project/
├── src/
│   ├── replit/
│   │   ├── client.ts       # Replit client wrapper
│   │   ├── config.ts       # Configuration management
│   │   └── utils.ts        # Helper functions
│   └── index.ts
├── tests/
│   └── replit.test.ts
├── .env.local              # Local secrets (git-ignored)
├── .env.example            # Template for team
└── package.json
```

### Step 2: Configure Environment
```bash
# Copy environment template
cp .env.example .env.local

# Install dependencies
npm install

# Start development server
npm run dev
```

### Step 3: Setup Hot Reload
```json
{
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "test": "vitest",
    "test:watch": "vitest --watch"
  }
}
```

### Step 4: Configure Testing
```typescript
import { describe, it, expect, vi } from 'vitest';
import { ReplitClient } from '../src/replit/client';

describe('Replit Client', () => {
  it('should initialize with API key', () => {
    const client = new ReplitClient({ apiKey: 'test-key' });
    expect(client).toBeDefined();
  });
});
```

## Output
- Working development environment with hot reload
- Configured test suite with mocking
- Environment variable management
- Fast iteration cycle for Replit development

## Error Handling
| Error | Cause | Solution |
|-------|-------|----------|
| Module not found | Missing dependency | Run `npm install` |
| Port in use | Another process | Kill process or change port |
| Env not loaded | Missing .env.local | Copy from .env.example |
| Test timeout | Slow network | Increase test timeout |

## Examples

### Mock Replit Responses
```typescript
vi.mock('@replit/sdk', () => ({
  ReplitClient: vi.fn().mockImplementation(() => ({
    // Mock methods here
  })),
}));
```

### Debug Mode
```bash
# Enable verbose logging
DEBUG=REPLIT=* npm run dev
```

## Resources
- [Replit SDK Reference](https://docs.replit.com/sdk)
- [Vitest Documentation](https://vitest.dev/)
- [tsx Documentation](https://github.com/esbuild-kit/tsx)

## Next Steps
See `replit-sdk-patterns` for production-ready code patterns.

Overview

This skill configures a reproducible local development loop for Replit projects with hot reload, environment management, and testing. It delivers a starter project layout, npm scripts for fast iteration, and recommended test setup using Vitest and tsx. The goal is to minimize turnaround time when developing and validating Replit integrations locally.

How this skill works

It scaffolds a predictable folder structure and local env handling, installs dependencies, and wires npm scripts to run tsx in watch mode for hot reload. It also provides a Vitest-based test template with mocking guidance so you can run tests and test-watch during development. Error guidance and debug flags are included to speed troubleshooting.

When to use it

  • Setting up a new Replit-based integration or plugin
  • Switching from remote to local-first development for faster feedback
  • Creating a reproducible team onboarding dev environment
  • Adding hot reload and test-watch to an existing Replit project
  • Iterating on SDK integrations and mocked endpoints locally

Best practices

  • Keep .env.local git-ignored and maintain a .env.example for teammates
  • Use a small client wrapper for Replit SDK calls to simplify mocking
  • Run tests in watch mode during feature work to catch regressions early
  • Use DEBUG environment flags for verbose logs when troubleshooting
  • Pin Node.js and dependency versions to avoid drift across machines

Example use cases

  • Start a new Replit plugin and iterate with instant reload using npm run dev
  • Write unit tests for your Replit client wrapper and run them in watch mode during development
  • Mock @replit/sdk to simulate responses and validate edge-case handling without live API calls
  • Onboard a teammate with .env.example, a single npm install, and npm run dev to reproduce your local loop

FAQ

What are the minimum prerequisites?

Node.js 18+ with npm or pnpm, a code editor with TypeScript support, and Git. Also complete any required Replit auth setup before running locally.

How do I enable hot reload?

Add a dev script using tsx watch (for example, "dev": "tsx watch src/index.ts") and run npm run dev. Use DEBUG=REPLIT=* for verbose logging.