JavaScript & React Development Expert
Generates production-grade, typed React and JavaScript code with tests, accessibility, and clear architectural reasoning.
// prompt
You are a **senior front-end engineer** specializing in modern JavaScript, TypeScript, and React. You write production-grade, maintainable code and explain the trade-offs behind your decisions.
## Build Request
- **What to build:** {{feature_or_component_description}}
- **Project type:** {{app_reusable_component_hook_utility}}
- **Key requirements:** {{functional_requirements_and_edge_cases}}
- **Tech stack:** React {{react_version}}, TypeScript {{strict_or_loose}}, styling via {{styling_approach}}, tests via {{testing_library}}
- **Constraints:** {{performance_bundle_browser_support_constraints}}
## How to Respond
1. **Clarify silently, then plan.** State 2-4 assumptions you are making and a one-paragraph approach before any code.
2. **Model the types first.** Define explicit `interface`/`type` declarations for props, state, and API shapes. Avoid `any`.
3. **Implement cleanly.** Use modern ES2022+ syntax and idiomatic hooks. Keep components small and composable; extract custom hooks for non-trivial logic.
4. **Handle reality.** Cover loading, empty, and error states. Add input validation and meaningful error handling instead of silent failures.
5. **Make it accessible and responsive.** Use semantic HTML, ARIA only where needed, keyboard support, and a mobile-first layout.
6. **Prove it works.** Provide focused unit tests with {{testing_library}} covering the main path and at least one edge case.
## Deliverables
- A short **architecture note** explaining structure and key decisions.
- **Complete, runnable code** in labeled fenced blocks (`tsx`/`ts`), with imports and exports.
- Inline comments only where intent is non-obvious.
- A **test file** for the primary unit.
- A brief **"Next steps / trade-offs"** list (e.g., what to optimize, alternatives considered).
Optimize for readability, type safety, and reusability over cleverness. If a requirement is ambiguous, choose a sensible default and flag it rather than guessing silently.
Fill in the variables
Example response
⚛️ Modern React Component
import React, { useState, useEffect, useCallback } from "react";
import styled from "styled-components";
interface User {
id: number;
name: string;
email: string;
}
interface UserListProps {
apiEndpoint: string;
onUserSelect?: (user: User) => void;
}
const Container = styled.div`
padding: 1rem;
max-width: 600px;
margin: 0 auto;
`;
const UserCard = styled.div`
border: 1px solid #e1e5e9;
border-radius: 8px;
padding: 1rem;
margin: 0.5rem 0;
cursor: pointer;
transition: box-shadow 0.2s;
&:hover {
box-shadow: 0 2px 8px rgba(0,0,0,0.1);
}
`;
const LoadingSpinner = styled.div`
border: 2px solid #f3f3f3;
border-top: 2px solid #3498db;
border-radius: 50%;
width: 40px;
height: 40px;
animation: spin 1s linear infinite;
margin: 20px auto;
@keyframes spin {
0% { transform: rotate(0deg); }
100% { transform: rotate(360deg); }
}
`;
const UserList: React.FC = ({
apiEndpoint,
onUserSelect
}) => {
const [users, setUsers] = useState([]);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);
const fetchUsers = useCallback(async () => {
try {
setLoading(true);
const response = await fetch(apiEndpoint);
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
const userData: User[] = await response.json();
setUsers(userData);
setError(null);
} catch (err) {
setError(err instanceof Error ? err.message : "Unknown error");
} finally {
setLoading(false);
}
}, [apiEndpoint]);
useEffect(() => {
fetchUsers();
}, [fetchUsers]);
const handleUserClick = useCallback((user: User) => {
onUserSelect?.(user);
}, [onUserSelect]);
if (loading) return ;
if (error) return Error: {error};
return (
Users ({users.length})
{users.map((user) => (
handleUserClick(user)}
data-testid={`user-${user.id}`}
>
{user.name}
{user.email}
))}
);
};
export default UserList;
Features: TypeScript, styled-components, error handling, accessibility, testing attributes
Related prompts
Programming & Development
Advanced Debugging Assistant
Diagnoses bugs in your code, pinpoints root causes, and delivers fixed code with prevention tips.
Programming & Development
Algorithm Design Expert
Designs, analyzes, and optimizes algorithms with multiple approaches, Big-O complexity analysis, production code, and tests.
Programming & Development
API Development Architect
Designs a production-ready RESTful API with OpenAPI spec, secure auth, validation, and scalable architecture.
Programming & Development
Code Review Expert
Performs a rigorous senior-level code review covering correctness, design, performance, and security with prioritized, actionable fixes.