PyCon Italia 2026: The Trends That Caught Our Attention

We've been sponsoring PyCon Italia since 2015 because it's one of the communities where we genuinely feel at home. This year we joined the conference as a Bronze Sponsor, contributed talks, and were also part of the organizing team that helped make the event happen.

Every year, PyCon Italia is more than just a conference. It's where we learn, share what we've been working on, and see where the Python ecosystem is heading next.

After comparing notes across the team, four themes stood out. Some are already changing how software is built today. Others are early signals worth watching closely.

1. AI is no longer "magic": it's becoming an engineering discipline

The conversation around AI has noticeably matured.

Instead of asking what AI can do, people are increasingly asking how to build AI systems that are maintainable, testable, observable, and reliable. Across several talks, the focus shifted from impressive demos to software engineering principles.

Giunio De Luca showed how to build Retrieval-Augmented Generation (RAG) systems using Hexagonal Architecture, keeping business logic independent from individual AI providers. His summary captured the mood perfectly: "RAG is the new CRUD."

The message is clear: RAG is no longer an experimental pattern. It's quickly becoming a standard building block for modern applications.

A similar idea appeared in Pythia, presented by Riboni e Paladini. Rather than treating prompts as disposable text, Pythia applies software engineering practices to prompt development: version control, automated testing, CI/CD pipelines, centralized prompt registries, and cost tracking across projects and teams.

Silvano Cerza approached the topic from almost the opposite direction in his talk AI Frameworks Are Making You Worse. His argument was that many AI frameworks introduce unnecessary layers of abstraction, making systems harder to understand and debug. In many cases, what appears to be an advanced framework feature can actually be implemented with a few lines of straightforward Python.

Another important theme was responsibility.

In Don't do anything (A)I wouldn't do, Luca Corbucci reminded the audience that AI systems are not accountable for the consequences of their decisions. Hallucinations, security risks, and increasingly autonomous agents make architecture and human oversight more important than ever.
Taken together, these talks reflect a broader shift.

The question is no longer: "What can AI do? Instead, it's becoming: "How do we engineer AI systems that can evolve, be tested, monitored, and corrected over time?” For us, this is probably the most significant change.

We're seeing AI move from being an isolated productivity tool to becoming part of the software development lifecycle itself. That means defining where it adds value, where human judgment remains essential, and how to integrate it into engineering workflows without sacrificing quality or maintainability.
In other words, AI is becoming less about shortcuts and more about software engineering.

2. Smaller models, sharper focus

One of the strongest signals we picked up at this year's conference came from multiple directions: the industry is becoming less obsessed with ever-larger foundation models and increasingly interested in smaller, specialized ones.

Rather than relying on a single model for every use case, the conversation is shifting toward choosing the right model for the right task. Stefano highlighted the growing adoption of small, open-source language models running locally, often fine-tuned for specific domains or workflows. The benefits are clear: lower costs, greater control over data, and the ability to tailor models to real business needs.
Another signal came from Merve Noyan of Hugging Face. As Sergey noted, her keynote painted a future where AI is increasingly multimodal, local-first, and powered by specialized open-source models rather than a single general-purpose system.

Andrea noticed another interesting shift: “growing interest in running smaller AI models locally”, accompanied by a “more measured attitude toward AI overall”. The excitement hasn't disappeared, but it's becoming more grounded. Teams are moving past the hype and evaluating AI based on practical outcomes, trade-offs, and real-world value.

Emanuela saw the same maturity from a broader perspective. Many of the most accessible use cases for generative AI have now been extensively explored, both in research and in production. As a result, the community is gradually shifting its attention toward more specialized, deep-tech challenges. Instead of asking what AI can do in general, the focus is increasingly on where it can solve specific, complex problems in a reliable and meaningful way.

Sergey pointed to a practical example of this shift in Maxim Danilov's talk on fully local AI agents. His approach combined speech-to-text, text-to-speech, OCR, and open-source language models into a system capable of running entirely offline, without relying on cloud services. The benefits are clear—greater privacy and full control over data—but technical constraints and licensing considerations still present challenges for large-scale adoption.

Taken together, these talks point to something larger than a technical trend.

It reflects a broader shift in how the community is evaluating AI: not just by raw capability, but by factors such as cost, control, adaptability, and fitness for purpose.

For teams with an open-source mindset, this way of thinking feels familiar. It's about choosing tools you can truly understand and control, building expertise instead of dependency, and selecting the right model for each task rather than relying on a single provider to solve every problem.

That's the same approach we're adopting internally. As AI becomes part of everyday software engineering, we believe long-term value comes not from using the biggest model available, but from making deliberate architectural choices that balance performance, maintainability, and independence.

3. Django's GeneratedField brings computed data into the database

Among the trends we identified, this is probably the most concrete from a technical perspective.

In his talk, Paolo Melchiorre introduced GeneratedField, a feature that allows database columns to be computed automatically from other model fields. Instead of implementing the logic in application code, the database becomes responsible for keeping derived values up to date.

Before GeneratedField, achieving the same result typically meant relying on signals, model hooks, or overriding the save() method—approaches that work, but often add complexity and maintenance overhead over time.

Sergey highlighted a few implementation details worth exploring, including the expression used to define the generated value, the output_field parameter that specifies its type, and the db_persist=False option, which avoids persisting the computed value when recalculating it on demand is more appropriate.

Leonardo immediately connected the feature to a real-world use case. He noted that GeneratedField would have significantly simplified part of a recent client project, although one aspect still worth investigating is how generated values behave after a model is saved. It's already on our list of features to test in upcoming projects.

At first glance, GeneratedField may look like a small addition to Django. In practice, it solves a common problem in a much cleaner way: moving the responsibility for computed data from application code to the database. The result is simpler code, fewer moving parts, and a smaller surface for bugs.

4. As AI writes more code, TDD may be changing its role (or disappearing altogether)

Lorenzo Spinelli's talk, TDD in the AI Era, sparked one of the most interesting discussions within our team because it could be interpreted in two different, and only partly compatible, ways.

For Iacopo, Test-Driven Development becomes even more valuable in an AI-assisted workflow. Tests help prevent the "creative" bugs that AI can introduce and give developers a way to guide the agent instead of simply accepting its output. In this view, the developer's role shifts from writing every line of code to defining clear, verifiable requirements that AI can implement.

Sergey took the idea a step further. Rather than practicing TDD in its traditional form, he sees the focus moving toward specifying the expected behavior, defining guardrails and safety checks, letting AI generate the implementation, and concentrating human effort on reviewing and validating the result.

Despite their differences, both perspectives point in the same direction: the value is moving away from writing code itself and toward defining what the software should do.

Where they diverge is in the role of testing. For Iacopo, tests remain a fundamental part of the development process. For Sergey, they may evolve into something different or become less central as new AI-driven workflows emerge.

That unresolved tension is precisely what makes the topic worth paying attention to. Even within the same conference, there was no clear consensus on how software development will change as AI becomes a standard part of the engineering toolkit. What seems certain is that the developer's role is evolving, and the industry is still figuring out what that evolution will look like.

Tools worth exploring

Not every takeaway from PyCon Italia is a trend. Some are simply tools or features that caught our attention and are worth experimenting with.

django-tasks / django-tasks-db
The official backport of Django's upcoming background task framework, scheduled to become part of Django 6.0 and already available for Django 5.2 LTS. If you're currently relying on Celery or similar solutions, it's worth understanding where Django's native approach fits before it becomes part of the standard ecosystem. For a deeper dive, our backend developer Juliana Nicacio presented a talk on the topic at PyCon Italia.

GeneratedField (Django 5.0+)
If the previous section caught your interest, the official Django documentation is the best place to start. GeneratedField is a small addition with the potential to simplify a surprising amount of application code.

Playwright
A powerful choice for end-to-end testing in Django projects, with built-in auto-waiting, test isolation, and an integrated inspector that makes debugging significantly easier. Our full stack developer and tech lead Leonardo Cavallucci presented a practical introduction at PyCon Italia, and the accompanying repository is available as a starting point for your own experiments.

connexion
A contract-first framework for building and mocking APIs directly from an OpenAPI specification. If you're curious about this approach, the open-source connexion-101 course provides a practical, hands-on introduction.

just / justfile
A modern alternative to Makefiles for managing project tasks. The syntax is cleaner, easier to read, and often less surprising. If your projects already rely heavily on Makefiles, it's well worth spending a few hours comparing the two approaches.

***

This article was put together from contributions collected across our team at PyCon 2026: Iacopo Spalletti, Emanuela Dal Mas, Leonardo Cavallucci, Stefano Ravagnan, Sergey Fedoruk, Mark Caglienzi, Juliana Nicacio, Paola Bianconi, Andrea Bravetti.