**Build software differently with AI at the core**

Software engineering is changing. At HeadFirst x Impellam, we are building an AI-native engineering organisation where AI is becoming a normal part of how we design, build, test and improve software.

As a Senior Full Stack Engineer, you will work across our .NET and Angular platform and take ownership of complex capabilities from technical design through to production.

You will still be the engineer responsible for what ships. The difference is how you get there. Tools such as Claude Code and Cursor help you investigate problems, write code, test ideas, refactor and document solutions faster. Your job is to give these tools the right context, challenge their output and make sure the final solution is secure, maintainable and fit for purpose.

If that sounds more exciting than spending your days manually writing every line of code, keep reading.

**What you will do**

You will work across the full stack and have ownership of the solutions you build.

Your work will include:

* Building end-to-end features across C#, .NET, ASP.NET Core, Angular and TypeScript.

* Using AI coding agents as part of your daily engineering workflow.

* Giving AI agents clear context, constraints and technical direction so they can contribute effectively.

* Reviewing AI-generated code and challenging it where needed on architecture, security, performance, maintainability and testability.

* Designing and evolving APIs, domain logic, data access layers and integrations.

* Building user-facing experiences together with Product and Design.

* Improving existing code and reducing technical debt as part of normal delivery.

* Writing meaningful unit, integration and end-to-end tests.

* Contributing to architectural decisions around scalability, reliability and multi-market expansion.

* Sharing knowledge and helping the wider engineering team get better at working with AI.

**What does senior mean here?**

For us, seniority is not about how quickly you can type or how much code you can produce.

It is about judgement.

You know how to look at a solution and ask the questions that matter:

* Does this fit the architecture?

* Are the assumptions actually correct?

* Is the security model sound?

* Will we still be able to maintain this in two years?

* Do the tests prove the right behaviour?

* Is there a simpler way to solve the problem?

* Did we give the AI agent enough context to make a good decision?

Whether you wrote the code yourself or an AI agent did most of the implementation, you remain accountable for the result.