Feature Development Agent

Implement user profile editing with avatar upload.

Tech stack: React + TypeScript, React Query, Tailwind, Jest + Testing Library
Constraints: Reuse existing Avatar and Form components from src/components/
Acceptance criteria:
- User can edit their name and upload an avatar
- Show optimistic updates while saving
- Include unit tests for form validation
- Add integration test for the full edit flow

Create a minimal implementation with all necessary files, tests, and a draft PR.

Add a POST /api/notifications endpoint that creates user notifications.

Stack: Node.js + Express, Prisma, PostgreSQL
Requirements:
- Accept: userId, title, message, type (info/warning/error)
- Validate all fields (title max 100 chars, message max 500 chars)
- Store in notifications table with timestamp
- Return the created notification with 201 status
- Include error handling and input validation tests

Follow the patterns in src/api/routes/ and match the existing error handling style.

Create a DataTable component that we can reuse across the app.

Stack: React + TypeScript, Tailwind
Features needed:
- Support sorting on any column
- Client-side filtering with search input
- Pagination (show 10, 25, 50, 100 rows)
- Loading and empty states
- Responsive on mobile (stack on small screens)

Make it generic so we can pass in any data shape. Include Storybook stories
showing 3 different use cases, plus tests for sorting and filtering.

Refactor src/services/email-sender.ts to be more testable and maintainable.

Current issues:
- Direct dependency on SendGrid (hard to test)
- No retry logic for failed sends
- Error messages aren't logged properly

Please:
- Extract an EmailProvider interface
- Implement SendGrid and a MockProvider for tests
- Add retry logic with exponential backoff (max 3 attempts)
- Improve error logging with structured data
- Update all existing tests to use the new structure

Users are reporting that the checkout flow fails ~5% of the time with a timeout error.

Stack: Next.js, Stripe, Redis for sessions
Error logs show: "Connection timeout to payment service"
What I know:
- Happens randomly, no pattern by time or user
- Session data exists in Redis
- Stripe API responds normally in test mode

Please investigate: explore the payment flow code, identify the likely root cause,
implement a fix, and add better error handling. Include tests that prevent this
regression.

Migrate our class-based React components to functional components with hooks.

Start with src/components/Dashboard/ (5 components)
Requirements:
- Convert class components to functional components
- Replace componentDidMount/Update with useEffect
- Use useState instead of this.state
- Keep all existing functionality and tests working
- Update tests to use React Testing Library instead of Enzyme
- Open a draft PR with the changes

Match the patterns you see in src/components/NewFeatures/ for consistency.

Add tests for src/utils/date-helpers.ts which currently has no test coverage.

This file has 8 functions for date formatting and manipulation.
Please:
- Write unit tests covering all functions
- Include edge cases (leap years, timezones, invalid inputs)
- Test boundary conditions (start/end of year, etc)
- Aim for 100% code coverage
- Run the test suite and make sure everything passes

Follow the testing patterns in src/utils/__tests__/ and use the same matchers.

The agent must analyze existing code more carefully before writing. It should:
find 2-3 examples of similar code, identify the style patterns (naming, structure,
imports), and match those patterns exactly. If multiple styles exist, ask which
to follow.

The agent should favor simplicity over cleverness. It should: use straightforward
solutions even if longer, avoid premature optimization, prefer explicit over
implicit, and only add abstraction when there are 3+ instances of duplication.
Ask "is there a simpler way?" before finalizing.

Every feature must include tests that would catch real bugs, not just tests that
pass. The agent should think: what could go wrong? What edge cases exist? What
would break if someone modifies this later? Write tests for those scenarios, not
just happy path.

The agent should limit PRs to: maximum 400 lines of changes (excluding tests),
one primary concern per PR, under 30 minutes to review. If a feature exceeds
this, it must be split into multiple PRs with clear dependencies. The first PR
should add the minimal working version.

Before making changes, the agent should: run the full test suite to establish
baseline, make incremental changes, run tests after each change, and immediately
revert if tests break. Never commit code with failing tests. If tests fail, fix
them or adjust the approach.

Connect the agent to your CI system (GitHub Actions, CircleCI, etc). When it
creates a PR, it should: monitor CI checks, fix failures automatically if
possible, and report status back to me. If CI fails, it should analyze logs,
identify the issue, and push a fix.

Track feedback I give during code reviews. When similar situations arise, the
agent should remember past feedback and apply those lessons. For example, if I
always ask for null checks in a certain pattern, the agent should add them
proactively.

For any UI changes, the agent should: take screenshots before and after, generate
visual diffs highlighting changes, and include them in the PR description. Use
tools like Playwright or Percy for automated visual testing.

Before starting work, the agent should estimate how long the implementation will
take (in hours). Base estimates on: lines of code to change, number of files
touched, test complexity, and integration points. Track actual vs estimated time
to calibrate future estimates.

For each feature, track important decisions: why we chose approach A over B,
what trade-offs we made, what we deferred for later, and what risks we accepted.
Store this in a DECISIONS.md file in each feature directory. Reference past
decisions when working on related features.