Full Stack AI Developer

We are hiring a full-stack developer who is already using AI coding tools to ship production software faster and more reliably.

We are looking for an engineer first. You should be able to understand a product requirement, inspect an existing codebase, implement the change, test it, open a clear pull request, review other pull requests, and support the feature through release.

Experience in insurance, claims, property risk, financial services, legal technology, or another regulated industry is useful, but it is not the primary requirement.

The primary requirement is that you can build, review, and ship good software.

You will work across the frontend, backend, database, APIs, integrations, testing, and deployment of an AI-enabled product.

You will use coding agents such as OpenAI Codex, Claude Code, Cursor, GitHub Copilot, or equivalent tools as part of your normal development workflow.

You must know how to use these tools effectively without blindly trusting their output.

You will be expected to:

• Take features from requirement through production
• Understand existing code before changing it
• Break work into small, reviewable units
• Write and maintain frontend and backend code
• Build APIs, workflows, integrations, and background processes
• Design and modify database schemas safely
• Write automated tests
• Open clear and focused pull requests
• Review pull requests from developers and coding agents
• Identify security, data, performance, and architectural risks
• Debug issues across the full stack
• Deploy and support production software
• Improve the codebase rather than simply adding more code

You must have hands-on experience using AI coding agents on real development work.

This includes the ability to:

• Give an agent the correct repository and task context
• Ask the agent to investigate before it changes code
• Turn broad requirements into bounded implementation tasks
• Prevent unnecessary rewrites and scope expansion
• Use agents for coding, testing, debugging, documentation, and review
• Run multiple agents or tasks in parallel when appropriate
• Check every material output before accepting it
• Detect hallucinated APIs, unsafe migrations, incomplete implementations, and weak tests
• Recover when an agent takes the wrong approach
• Keep generated work consistent with the architecture of the existing system
• Produce understandable commits and pull requests from agent-generated work

We are not looking for someone who can paste a requirement into an AI tool and accept whatever comes back.

We are looking for someone who can direct, constrain, inspect, and improve agent-generated work.

You should understand that different models are suited to different tasks.

You must be able to explain how you choose between models based on:

• Coding ability
• Reasoning depth
• Repository context size
• Speed
• Cost
• Tool-use reliability
• Structured output reliability
• Debugging complexity
• Data sensitivity
• Review requirements

You should know when to use:

• A fast model for mechanical edits
• A stronger reasoning model for architecture or difficult debugging
• A long-context model for repository analysis
• A coding-focused model for implementation
• A separate model or agent for review
• Deterministic code instead of an LLM

Using the most expensive or most powerful model for every task is not good judgement.

Pull requests are central to how we work.

You must be able to create PRs that clearly explain:

• The problem being solved
• The implementation approach
• The important changes
• The assumptions made
• How the work was tested
• Any known risks or limitations
• Any deployment, migration, or rollback requirements
• How another engineer can verify the change

We expect:

• Small and focused PRs
• Clear commit history
• Useful PR descriptions
• Tests for important behaviour
• Screenshots or recordings for significant UI changes
• Links to the relevant issue or requirement
• Migration and rollback notes where needed

Large, unexplained code dumps are not acceptable.

You must also be comfortable reviewing code written by developers and coding agents.

A useful review should identify issues involving:

• Incorrect requirements or assumptions
• Data integrity
• Authentication and authorization
• Security
• API contracts
• Database migrations
• Race conditions
• Idempotency
• Error handling
• Retry behaviour
• Performance
• Accessibility
• Test quality
• Backward compatibility
• Observability
• Deployment safety
• Unnecessary complexity

You must be willing to challenge a PR that looks technically polished but solves the wrong problem or introduces unacceptable risk.

You should have strong experience with a modern full-stack web stack.

Relevant experience includes:

• React
• TypeScript
• Next.js or a similar framework
• Component-based UI development
• Responsive and accessible interfaces
• Forms and validation
• State management
• API integration
• Frontend testing
• Browser debugging

• TypeScript, Node.js, Python, or equivalent
• REST APIs or GraphQL
• Authentication and authorization
• Background jobs
• Queues
• Webhooks
• File and document processing
• Third-party integrations
• Retry-safe workflows
• Structured logging
• Error monitoring

• PostgreSQL or another relational database
• SQL
• Schema design
• Database migrations
• Transactions
• Indexing and query performance
• Audit history
• Redis or equivalent caching and queue systems

Experience with geospatial data or PostGIS is useful.

• LLM API integration
• Structured outputs
• Tool or function calling
• Prompt and context management
• Retrieval-augmented generation
• Model routing
• Evaluation and regression testing
• Guardrails and validation
• Human-in-the-loop workflows
• Cost and latency monitoring
• Tracing AI and agent actions
• Handling incomplete or unreliable model output

We value reliable AI-enabled systems more than impressive agent demonstrations.

• Git
• GitHub
• Pull request workflows
• CI/CD
• Automated testing
• Docker
• Cloud deployment
• Secret and environment management
• Logs, metrics, and tracing
• Production debugging
• Safe release practices

Insurance experience is useful but not required.

Relevant areas include:

• Property insurance
• Claims
• First notice of loss
• Weather events
• Catastrophe response
• Business interruption
• Statements of values
• Policy and coverage data
• Damage assessment
• Portfolio risk
• Legal workflows
• Financial recovery
• Evidence management

Experience in financial services, legal technology, compliance, healthcare, or another regulated environment is also useful.

You should be comfortable building software where decisions may need to be explained, reproduced, and audited.

Every applicant must provide a repository that they personally own or substantially maintain.

No repository, no application.

The repository may be public, or you may provide private access.

It must contain meaningful original work. A copied tutorial, bootcamp project, generated template, or codebase you cannot explain will not be considered sufficient.

We will review:

• Code quality
• Architecture
• Commit history
• Pull requests
• Tests
• Documentation
• Error handling
• Security awareness
• Deployment configuration
• Evidence of ownership
• Evidence of ongoing development

You must be able to explain:

• What you personally built
• Which parts were generated or assisted by AI
• Which agents and models you used
• How you checked generated code
• A difficult bug you diagnosed
• A technical decision you would now change
• How the system is deployed
• What would fail first under significantly higher usage

The repository does not need to be large.

A small, well-designed, tested, and deployed product is more valuable than a large repository that you do not fully understand.

Your application must include:

1. A link to a repository you own or substantially maintain
2. A short description of the product
3. A clear explanation of the work you personally completed
4. A pull request you created
5. A pull request you reviewed, where available
6. The coding agents you currently use
7. How you choose different models for different tasks
8. An example of a mistake or risk introduced by AI-generated code
9. Your experience deploying and supporting production software
10. Any relevant insurance or regulated-industry experience

Applications without a repository will not be reviewed.

We use AI as part of our interview process.

Your own thinking, judgement, and practical experience are more valuable to us than an answer that is more polished, comprehensive, or technical because it was generated by AI.

Do not use AI to generate or disguise your interview answers. Our interview process is specifically designed to identify answers that do not reflect the candidate’s actual knowledge and experience.

We are looking for engineers first.

The interview process may include:

• A review of your repository
• A discussion of your architecture and technical decisions
• A pull request review exercise
• A debugging or investigation exercise
• A bounded agentic development exercise
• Questions about how you use Codex or other coding agents
• Questions about how you validate AI-generated code
• Questions about model selection, tradeoffs, and failure cases

We are not assessing typing speed or the ability to produce a perfect theoretical answer.

We are assessing whether you can understand a system, make sound engineering decisions, use AI tools responsibly, and ship reliable software.

Strong candidates:

• Have shipped real software
• Can work across the full stack
• Understand Git and pull request workflows
• Can review code critically
• Use coding agents regularly
• Can explain when and why they use different models
• Verify AI-generated work
• Write useful tests
• Think about failure cases
• Communicate technical decisions clearly
• Can work from an outcome rather than a fully detailed ticket
• Care about maintainability, security, and production behaviour
• Take responsibility for the result, not just the code

This role is unlikely to suit someone who:

• Cannot provide a repository
• Cannot explain their own code
• Has only tutorial or bootcamp projects
• Relies on AI-generated code without reviewing it
• Needs every task fully specified
• Avoids pull request reviews
• Has never deployed production software
• Cannot work across frontend and backend
• Uses the same model for every task
• Produces large, unfocused PRs
• Confuses code generation with software engineering
• Optimizes for writing more code rather than delivering reliable outcomes
• No repository, no application.