AI-Native Technologists

Between August and November 2025, Sigma Labs trained it's first cohort of AI-native consultants. This report summaries the outcomes of that training, and the lessons learned.

We defined "AI-Native Consultants" as professionals who have been trained from the outset to leverage large language models (LLMs) and related AI technologies as integral tools in their consulting practice. This contrasts with traditional consultants who may adopt AI tools later in their careers.

Our hypothesis was that AI-Native Consultants would demonstrate superior performance in project delivery, problem-solving, and client outcomes compared to their traditionally trained peers. We actively worked against the risks of AI over-reliance by embedding several techniques to ensure critical thinking and domain expertise remained central to our training.

The release of GitHub Copilot in mid-2021 marked a watershed moment for software development: for the first time, a large-scale model trained on public repositories could sit alongside a developer in their IDE and suggest entire functions, boilerplate, or even complex algorithms in real time. Powered by OpenAI’s Codex, Copilot demonstrated that AI could move beyond simple autocomplete and into a true “pair-programming” paradigm. Early adopters praised its ability to reduce repetitive coding tasks, speed up prototyping, and introduce best-practice patterns.

In the years since, an ecosystem of AI co-pilot tools has emerged. Cursor, Tabnine, Amazon CodeWhisperer, and enterprise LLM integrations now vie for developers’ attention, each bringing its own strengths - whether tighter on-prem security, better support for specialised languages, or deeper integration with cloud pipelines. Meanwhile, chat-based assistants like ChatGPT and Anthropic’s Claude offer natural-language debugging, architectural guidance, and even test-generation features. As these co-pilots learn from private codebases and context, they’re shifting from generic suggestion engines to customisable teammates that understand a team’s coding conventions, security policies, and domain-specific libraries.

On the horizon, we see new ‘Agentic’ tools that promise the ability to replace junior or mid-level technologists completely by empowering the AI to complete multi-step actions encompassing the full software development lifecycle. Development is progressing at pace with tools such as Devin.ai , but a proven track record to produce industry-standard code on large existing codebases is yet to be seen.

The hypothesis that this document is predicated on is that AI tools will continue to become more powerful and companies will realise that without the performance gained from using it, they won’t be able to keep up with the speed at which their competitors can ship software.

Industry Research

Within start-ups we’ve seen a much larger uptake, with one quoting that they believe 80%+ of their codebase has been written by AI. Most notably, this quote shows the dramatic uptake that has been.

“There is code that has been written, tested, deployed and will - eventually - be removed without ever having had a human see it”

This reinforces the sense from industry that the current suite of tools is most useful for greenfield projects, with limited scope, where moving fast is preferable to solving problems comprehensively.

This rapid uptake by very early-stage start-ups can be explained by the forcing effect that limited resources have on small companies. Poor quality code is unlikely to force them to close; not having a product-market fit will.

More widely in the industry, the Stack Overflow Developer Survey 2024 stated that

76% of all respondents are using or are planning to use AI tools in their development process this year, an increase from last year (70%). Many more developers are currently using AI tools this year, too (62% vs. 44%).

In the world of Big Tech, adoption within teams building the tools (i.e. the most obvious first adopters) is surprisingly high. Tim Rogers (Product Owner at Github) shared their data on HackerNews

So far, the agent has been used by about 400 GitHub employees in more than 300 our our repositories, and we've merged almost 1,000 pull requests contributed by Copilot. [..] In the repo where we're building the agent, the agent itself is actually the #5 contributor - so we really are using Copilot coding agent to build Copilot coding agent [...]

To summarise, adoption is accelerating rapidly across all business

• Fast-moving start-ups have seen revolutionary change in their processes
• Big tech at the bleeding edge has also seen the value

In the research paper titled 'The AI-Native Software Development Lifecycle: A Theoretical and Practical New Methodology', the authors speak about a radical change in the places that take up the most time when producing software. This relies on the ‘V-Model’ of software development (see Figure 1 below), which tries to describe the way software is built.

In this model, cheap, junior technologists are brought in to tackle the largest bottleneck in this system (represented by the largest box) - writing the code. This is not technically the hardest part of the problem, and if the problem has been well defined and structured, this should be achievable for juniors to complete with support.

However, with the use of AI, this model would be transformed to look more like this - the ‘V-Bounce’ model (see Figure 2 below). In this new model, it is apparent that the bottleneck in this system is no longer writing code - which is mostly automated - but rather in the requirements gathering and testing phases of the project. We hypothesise that one outcome of this is that companies will now be hiring cheap, junior technologists to work at the new bottleneck of production - requirements gathering and quality assurance.

There are, of course, many other bottlenecks in a software project - architecture, deployment and cross-team coordination - that aren't solely code-generation issues. But these will often fall outside a junior engineer's remit, sitting with an Architect or Tech Leads to work through.

Our hypothesis is that junior technologist will now need to be highly skilled in these three areas to be effective in this new world:

1. Use AI to generate code to solve problems and maintain productivity

• Write a concise prompt that specifies the programming language, input/output formats, and any edge-case requirements.
• Provide relevant context (existing code, data schemas, dependencies) so the AI generates code that fits the project.
• Compare multiple AI outputs, choose the best one, and refine the prompt to address missing features or bugs.
• Review every line of AI-generated code for correctness, performance, and security before merging.

2. Work with stakeholders to ensure they're solving the right problem

• Schedule and lead meetings to capture business goals, constraints, and success metrics.
• Turn stakeholder input into concise user stories, acceptance criteria, and manual decomposition before prompting AI.
• Provide regular, transparent updates on progress, highlighting both AI-generated work and manual changes.
• Document edge-cases, data-privacy needs, and potential AI hallucinations so risks are visible from day one.

3. Ensure high quality output through comprehensive user testing and validation

• Define clear test scenarios (unit, integration, end-to-end) before asking AI to scaffold tests.
• Prompt AI tools to generate initial test cases, then refine or extend those tests to cover edge cases.
• Automate QA checks in CI/CD pipelines so every commit undergoes the same rigorous validation.
• Track and report test coverage, code quality metrics, and security findings to the team.

In this section, we highlight the risks if AI-Native Technologists were to outsource the majority of the writing of their code to an AI Copilot. These risks are split into:

• Consultant Risk: Short or long-term performance risk to our Consultants
• Client Risk: Security, financial or reputational risk to our Clients

Consultant Risk: Skill Atrophy

Over-reliance on AI erodes fundamental coding skills and problem-solving abilities

Relying too heavily on AI for code generation can erode a developer's fundamental skills, like breaking problems down, writing algorithms by hand and debugging complex issues.

Over time, they may lose confidence in solving novel challenges without an AI crutch and fail to build the deep understanding needed for robust, maintainable software. This "skill atrophy" may undermine their long-term growth and adaptability as technologists.

Sources:

• Microsoft Study Finds Relying on AI Kills Your Critical Thinking Skills

Consultant Risk: Failure to Attain Mastery of Tools

Superficial knowledge prevents deep understanding and troubleshooting ability

Failure to attain true mastery of AI tools means trainees may develop only a "veneer of knowledge" - the illusion of skill without the deep understanding that comes from hours of trial, error, and deliberate practice. Without wrestling through tedious, hands-on challenges, they risk knowing which buttons to click but not why or how the underlying systems work.

This superficial familiarity leaves them unable to diagnose failures, optimise workflows, or innovate when AI suggestions fall short. It is almost certain that with the current state of AI tools, the AI will assist in 90% of the task, but the final, hard 10% will still require a technologist's direct involvement in the code.

Consultant Risk: Code Comprehension & Critical Review

Reduced ability to understand, assess, and improve AI-generated code

Code comprehension and critical review refer to the ability to deeply understand, assess, and improve any code, even when it is generated by AI. Without having to write all of the code themselves, trainees may not truly understand what each part does or why it was written in a particular way.

They might also take the AI's word on what high-quality code is without building the skills to judge this for themselves. This can lead to hidden bugs, design flaws, and missed learning opportunities, as technologists fail to question, critique, or improve the AI's suggestions, ultimately weakening both individual confidence and team code quality.

Client Risk: Security Implications & Business Risk

AI-generated vulnerabilities expose organisations to breaches and compliance failures

AI-generated code can unknowingly introduce security vulnerabilities, such as un-sanitised inputs, weak authentication, or misconfigured permissions, that the model itself cannot detect. If these flaws reach production, they leave organisations exposed to data breaches, service outages, and regulatory non-compliance. The resulting incidents damage reputation, erode customer trust, and can incur significant financial penalties.

Without rigorous security reviews and automated vulnerability scanning of every AI-suggested snippet, businesses risk embedding dangerous weaknesses into their systems. For example:

• Generating infrastructure scripts that open network ports broadly or disable firewalls by default – exposes internal services to the internet, allowing attackers to probe and breach systems.
• Disabling TLS certificate validation in HTTP clients – leaves data in transit open to interception or tampering, enabling undetected man-in-the-middle attacks.
• Failing to sanitise user-supplied file paths – permits directory traversal or arbitrary file reads, risking exposure of sensitive files and potential remote code execution.

Client Risk: Licence & IP, or Data Exposure

Restrictive licences and PII leakage create legal and compliance risks

Generative models trained on billions of lines of public code can inadvertently reproduce snippets governed by restrictive licences or reveal patterns that mirror proprietary implementations. Trainees who accept AI-generated code verbatim risk tainting their organisation's codebase with third-party licence obligations or exposing internal logic and secrets to external systems.

Additionally, most AI systems require users to send entire code blocks to them in order to be expanded upon. If a technologist was to - meaningfully or otherwise - send Personally Identifiable Information (PII) to a provider of AI it could break EU/US law (e.g. GDPR).

Examples:

• Embedding a block of AI-generated code under the GPL into a closed-source microservice—thereby forcing the entire service to adopt a copyleft licence.
• Incorporating an MIT-licensed helper function without attribution or a licence header, creating confusion over permitted reuse.
• Pasting a snippet containing a customer's full name, date of birth and transaction history into ChatGPT to clarify a formatting error, thereby transmitting sensitive PII to the OpenAI service without the user's consent or organisational approval.

Tools & Technology Selection

Throughout our AI-Native training programme, we conducted extensive experimentation across multiple categories of AI tools to identify the optimal technology stack for our consultants. Our evaluation focused on real-world performance, learning curve, and suitability for professional consulting environments.

Chat-Based AI Assistants

ChatGPT, Gemini, and Claude compared for technical problem-solving

We considered: ChatGPT, Gemini, Claude

We chose: Claude - Demonstrated the best ability when working with code, provided more structured and actionable responses, and excelled at explaining trade-offs in architectural decisions. Particularly effective when working in Learning Mode.

ChatGPT offered strong general-purpose capabilities, and was preferable for inter-personal interactions around AI. Gemini provided good integration with the Google ecosystem but showed inconsistent performance on complex technical queries and architectural guidance, however we brought this in later in the programme and experimented with it less.

Generative Coding Tools

GitHub Copilot and Cursor evaluated for in-IDE assistance

We considered: GitHub Copilot, Cursor

We chose: GitHub Copilot - Offered the most seamless IDE integration, particularly with VS Code. Excellent context awareness and reliable completions across python. It seemed to respond well to the `copilot-instructions.md` file and we could prompt it when when using auto-complete.

Cursor provided innovative features and powerful multi-file editing capabilities, but had a steeper learning curve, higher barrier to entry and didn't integrate as well with the rest of our stack.

Agentic AI Development Tools

Claude Code, Copilot Workspace, and Codex for autonomous development

We considered: GitHub Copilot (Workspace), OpenAI Codex, Claude Code

We chose: Claude Code - Significantly outperformed alternatives with exceptional ability to:

• Understand complex project requirements and break them into actionable steps
• Navigate large codebases and maintain context across multiple files
• Execute full development lifecycles including implementation, testing, and debugging
• Provide clear explanations of its reasoning and approach
• Handle edge cases and error scenarios with minimal intervention

GitHub Copilot (Workspace) offered extended capabilities beyond code completion, but with limited autonomous action and still requiring significant developer guidance for complex tasks. OpenAI Codex provided powerful code generation from natural language, but was less integrated into full development workflows with limited ability to handle multi-step, context-dependent tasks.

The combination of Claude Code for agentic development tasks with GitHub Copilot for in-editor assistance proved highly effective. Claude Code's superior reasoning and multi-step execution capabilities made it indispensable for complex project work, whilst Copilot provided reliable day-to-day coding assistance.

Security & Code Quality Tools

Snyk for vulnerability scanning and licence compliance

We considered: Snyk, SonarQube, Checkmarx, GitHub Copilot in Pull Requests

We chose: Snyk - Deployed for comprehensive security analysis of AI-generated code. Provides:

• Real-time vulnerability scanning for dependencies and code
• Licence compliance checking to prevent IP violations
• Integration with CI/CD pipelines for automated security gates
• Clear remediation guidance for identified vulnerabilities

Additionally, we used GitHub Copilot in Pull Requests to provide AI-assisted code review suggestions, helping to catch potential issues and improve code quality during the review process.

This combination of tools created a robust, secure, and highly productive development environment. By carefully selecting best-in-class tools for each category, we enabled our AI-Native consultants to work at significantly higher velocity whilst maintaining code quality and security standards.

Impact on Productivity

Independent Learning

To assess the impact of AI-Native training on independent learning speed, we compared the time taken by both traditional and AI-enabled training groups to the coursework of our programme. The modules covered new technologies and concepts not previously encountered by either group. Additionally, the AI-enabled group were given less details for the projects to complete, requiring them to research more independently.

What we found, was that by the time that trainees were fully ramped in terms of AI tooling (i.e. using generative and agentic coding and LLMs regularly) they were able to complete the coursework to same standard, to a high level of understanding, in 19% less time on average.

Group Projects

To measure the impact of AI-Native training on productivity, we compared the Group Project outputs between traditional and AI-enabled training groups. Both groups worked on the same project briefs with the same complexity and timeframes. The visual comparison below demonstrates the significant difference in output and complexity achieved by AI-enabled consultants.

A visual comparison demonstrates that AI-Native consultants not only completed more projects within the same timeframe but also tackled projects of greater complexity and scope. This represents a significant productivity multiplier while maintaining code quality and architectural standards.

Below you will find two graphs that visualise lines written and cytometric complexity. Whilst independently, the two graphs below don't give important insights, it is worth noting that AI-Enabled trainees have managed to write 6.5x the code, whilst also maintaining a low complexity score.

Consultant Performance & Quality

To evaluate the effectiveness of our AI-Native training approach, we conducted a series of standardised interview assessments comparing AI-Enabled consultants against those trained using traditional methods. The results demonstrate consistently higher performance across all interview formats.

Consultant Feedback & Self-Reflection

We collected feedback from consultants who completed the AI-Enabled training programme. Their responses provide valuable insights into the effectiveness of the approach and areas for improvement.

What Consultants Loved

"I liked the fact that I was able to use advanced AI's in a professional setting and really scale up the level and quality of my work"

"Significantly speeds up gaining familiarity and general mastery over new technology tools, more efficient than reviewing over docs and simplifies learning through summary"

"I liked most the deeper understanding gained from code defence, I feel this took me beyond simply doing to understanding AWS more deeply which is so valuable in industry"

Key positive themes that emerged:

• Immediate Support: Consultants valued getting instant explanations and debugging help, accelerating their workflow
• Tool Exposure: Exposure to diverse AI tools (Claude's generative and agentic versions, Copilot) expanded their technical toolkit
• Deeper Understanding: Code defences forced deep comprehension, taking consultants beyond surface-level completion
• Learning Efficiency: AI as a learning tool proved highly effective, with 3 consultants reporting 50-70% learning gains

Areas for Improvement

Consultants also identified several areas where the programme could be enhanced:

• Agentic AI Caution: Concerns about over-reliance on agentic AI tools (like Claude Code), with recommendations to introduce them later in training or use them more sparingly
• Assessment & Feedback: Need for clearer assessment criteria and more consistent feedback, particularly around gauging true understanding vs AI-generated work

Firstly, it is important to acknowledge that all of the data collected in this report is from a relatively small sample size. Whilst the results are promising, further study with larger cohorts and over longer timeframes will be needed to validate these findings. We're excited to continue refining our approach and measuring outcomes as we scale our AI-Native training programme.

The shift to AI-Native technologists represents a fundamental change in how we train and deploy junior engineers. By focusing on requirements gathering, stakeholder management, and quality assurance, we prepare consultants for the new bottlenecks in software development.

Our AI-Native training programme has demonstrated significant gains in productivity and quality, with consultants completing work faster while maintaining high standards. The emphasis on active learning, code defences, and AI best practices ensures that consultants develop deep understanding rather than superficial reliance on AI tools.

As AI continues to evolve, so too must our training methodologies. We are committed to refining our approach based on feedback and outcomes, ensuring that our consultants remain at the forefront of this transformative era in technology.

Want to learn more about our AI-Native Consultants or hire our services?

Get in touch at clients@sigmalabs.co.uk