Hands-on AI training: the Nephila approach
Some tools enter everyday work through a formal adoption process: a rollout plan, training, and time to learn. Others arrive through the back door.
At Nephila, AI assistants took the second route. People started experimenting independently, each with their own prompts, configurations, and habits. For a while, that worked well: individual experimentation is a quick way to discover what a tool can do. Eventually, though, we found that very different working practices coexisted within the same team. Some were effective, others less so, and few were shared.
We decided to address this at two levels. Across the company, both technical and non-technical colleagues needed a foundation in AI literacy: shared terminology, an understanding of the tools’ limitations, and the ability to assess their output.
This also aligns with Article 4 of the EU AI Act (Regulation (EU) 2024/1689), as amended by the Digital Omnibus on AI (Regulation (EU) 2026/1744). It requires providers and deployers to take measures supporting the development of AI literacy among staff and others using AI systems on their behalf, taking account of their knowledge, experience, training, and working context.
For senior developers, we needed to go further. The question was no longer “Are we using AI?” but “Can we explain how we use it, when it works, and why it sometimes fails?”
That led us to design a training programme for experienced engineers: a way to turn individual use of AI assistants into a deliberate, measurable, shared engineering practice. This approach also supports the AI literacy objectives of the EU AI Act, giving the team a method it can apply, evaluate, and refine as the tools evolve.
This article explains how we built the programme, what we learned from running it with our own team, and the questions that come up when we discuss it with others.
Moving beyond individual habits
What happens when a team adopts AI without developing shared practices?
In our experience, habits diverge. Some developers distrust the tools and miss opportunities where they could be useful. Others place too much confidence in generated output and integrate it without sufficient verification.
Across both groups, we found a less obvious problem: the lack of a shared vocabulary. When everyone evaluates AI assistance based on whether it “feels useful”, comparing approaches becomes difficult. This also makes it harder for the team to improve those practices together.
The programme therefore develops three capabilities in parallel. The first is conceptual understanding: how language models generate responses, how context influences their behaviour, and where their limitations come from. The second is quantitative evaluation: how to assess prompts and workflows using evidence rather than impressions. The third is the engineering skills needed to build workflows and agents, with the foundations required to take them into production
These capabilities support one another. Conceptual understanding needs empirical testing. Evaluation needs a sound interpretation of what is being measured. Implementation needs both to avoid building fragile systems.
Six connected modules that lay the foundation for shared practices
The programme consists of six modules. Each builds on the previous one, so the sequence is part of the design.
We start with a shared vocabulary for prompt patterns. Before discussing agents, we need a common understanding of how to structure instructions. We then introduce data analysis tools, Jupyter, pandas, and ipywidgets, and explore the mechanisms behind model behaviour. This gives participants tools for investigating results as well as concepts for interpreting them. From there, we examine how a senior developer’s responsibilities change when delegating implementation to AI agents. Defining requirements, setting constraints, coordinating execution, and reviewing results become increasingly central. This is particularly relevant to a team preparing to rebuild a system with substantial AI assistance. The programme then introduces quantitative prompt evaluation. Participants use observability tools to trace executions and run controlled comparisons between variants. Finally, we move from using existing agents to building them from scratch.
The programme alternates three self-paced online courses with three remote workshops. Each format serves a different purpose. The courses cover material that participants can work through independently: terminology, tools, and approaches to AI-assisted development. We selected practical courses from an international learning platform, with content developed by universities and established technology companies.
The workshops focus on subjects that benefit from investigation and discussion: model behaviour, prompt evaluation, and the use of data analysis tools. We designed and tested these workshops internally with Stefano Ravagnan, a backend developer and tech lead involved in research, experimentation, and technological innovation at Nephila.
The design work also includes selecting the self-paced courses and developing guided support alongside practical application. This keeps the programme connected to the team’s work, beyond completing course material. The training does not include building a complete AI workflow for a production project. We deliberately leave that work to the projects themselves, where requirements, constraints, and consequences are real.
The programme provides the concepts, tools, and shared language. Teams then put them into practice on real projects, with structured ways of working and specialist support.
What we learned from training our own team
Before offering the programme to others, we tested it with our own team.
The first thing we learned was that natural language interaction can be misleading. Talking to an agent feels like talking to a person: you explain what you want, and it gets to work. In practice, words we often use almost interchangeably, such as “verify” and “validate”, can lead an agent to interpret instructions differently and take different actions. When the goal is to let an agent work independently for hours while you focus on something else, these details matter. Similarly, understanding tokens and how an agent manages context helps explain how to structure instructions, write clear tasks, and avoid reaching usage limits too quickly. What may seem like theory has practical value: it helps developers use the tools effectively and make better use of their capabilities.
The second lesson was about choosing and applying a shared method. Developers tend to configure their assistants with different instructions, skills, and tools, so the same request can produce different results. In effect, everyone has their “own” agent. We therefore agreed on how we wanted to work with these tools and established shared rules and infrastructure. Whether code is written by a person or their agent, it needs to meet consistent standards. As the person coordinating the agents’ work, the senior developer must define clear goals and requirements, delegate execution, and check that the result meets those expectations.
We found that the biggest challenge was keeping up. The tools evolve so quickly that a method needs regular review, and a shared vocabulary makes it easier to update it together. Most importantly, our experience confirmed that the programme’s structure can be reused. It was designed to extend beyond a single use case and can be adapted to teams with different needs.
Questions we are often asked
When we discuss the programme, the same questions tend to come up. Most raise valid concerns, so they deserve a closer look.
“In this field, you learn by doing. Isn’t practical experience enough?” Practical experience remains essential, but AI can be used at very different levels. Using a chat interface is accessible to most people; achieving consistently better results requires a deeper understanding. A shared programme gives everyone that foundation without each person having to work through everything independently. It also provides something individual practice alone cannot establish: a common language and a shared method.
“If everyone on the team already uses AI effectively, why do we need a shared method?” Because, on a shared project, different developers’ agents work on the same codebase. Without dedicated time to compare approaches, people tend to stick to their own habits, especially when tools change quickly and delivery deadlines take priority. Developing shared guidelines is itself a learning opportunity: comparing how colleagues work can teach us a great deal.
“What stays with the team after the training ends?” The method. Team members change, and projects and partnerships come to an end, but a tested, shared method helps maintain continuity. This is where the lasting value lies: the investment builds the organisation’s ability to work effectively and independently with these tools, beyond any individual course.
“Should we adopt your training programme exactly as it is?” No. We are sharing the programme that worked for us, but each organisation needs to develop its own method based on its domain and existing practices. Training and practical application can also progress in parallel, particularly in teams that already use AI in sophisticated ways.
The programme described in this article prepares teams for practical experience. Projects remain the real test: this is where a trained team can judge when to trust an output, when to investigate further, and how to demonstrate with data that one approach performs better than another. With tools evolving faster than anything we have experienced before, we know there is still plenty to learn.
If AI adoption in your team also began informally, and you want to develop a more deliberate approach, get in touch. We would be happy to explain how we work and adapt the programme to your team’s needs.
***
We wrote this article with the support of AI. If you're interested in how we use these tools as part of our writing process, you can read more here.
Related posts
Learning to read AI: what the AI Act says about literacy
- ByPaola Bianconi
- / News
The AI Act asks companies that build or use AI systems to support AI literacy across their teams. We look at what Article 4 requires after the 2026 Digital Omnibus, how to show you’re compliant and what we’ve done at Nephila.
Just a game? How the AI Act found its way into how we build software
- ByPaola Bianconi
- / News
Risk, transparency, human oversight: how the AI Act’s principles shaped the design of our AI Debug Challenge, even though it’s just a game.
