Forem: Alberto Gianfranco Meleleo

Prototyping with AI Agents: Rethinking Discovery

Alberto Gianfranco Meleleo — Fri, 27 Jun 2025 09:20:25 +0000

In the modern software development flow, we often underestimate the value of the discovery phase. It is at this moment, whether initial, or iterative, that insights are born, vision is ignited, and the first point of contact between team, product, and user is created. It is also the moment when prototypes take on a key role.

The Evolution of Prototypes

Prototypes are often generated based on tools such as figma, wireframes or Draft applications in order to interact with the customer, prototypes in which an attempt is made to capture the essence of an idea. But that code, while raw, has a deeper purpose: to stimulate conversations, to validate insights, to generate alignment between business, design and technology. It should not be just a technical exercise, but the creation of a bond, a collaboration with the customer.

Today, thanks to AI agent-based tools, this kind of prototyping takes a new form that changes the interaction with stakholders. Where before the process was fragmented and asynchronous (show, gather feedback, edit, schedule a new meeting) it now becomes fluid and instantaneous. It is no longer about writing code quickly, or creating wireframes and/or figma but about generating interactive experiences in minutes, even while talking to the stakholder by putting continuous dialogue at the center rather than time-diluted review cycles.

AI Agents and the New Discovery

With the rise of AI agents, we are seeing a radical transformation of the discovery phase. In my experience, I have experimented with different tools, each with its own peculiarities and specific use cases.

Lovable: From Idea to Prototype in Natural Language

Lovable stands out for its accessibility. Imagine you need to quickly prototype an app for managing shared expenses in a group of friends. Instead of drawing wireframes, you can simply write, “Create an app where users can add expenses, share them among group members, and see who owes what to whom.”

In just a few minutes, Lovable generates a working interface complete with an expense entry form, participant list, and sales dashboard. The added value? You can immediately share the link with the customer and gather concrete feedback.

I like it, but I wish the owes were more visible

instantly becomes a new iteration.

bolt.new: Transparency for Developers

bolt.new takes a different approach, constantly showing the generated code. When I had to prototype a reservation system for a coworking facility, I appreciated how each change was translated into specific commands. By typing “Add a calendar with available time slots,” I could immediately see the generated React component and figure out how to integrate it later into the main project.

The choice between React, Vue, Svelte or even React Native for mobile allows you to prototype directly into the target technology, reducing the gap between prototype and final.

From Prototype to Insight

These tools are redefining Discovery because they turn every conversation into an opportunity for prototyping. No longer “Imagine if…” but “See what happens if….” They lower technical barriers, speed up feedback loops, and make it possible to prototype with the customer, not just for the customer.

The real revolution is not in the speed of generation, but in the ability to iterate with the customer, to see his or her reactions in real time on something tangible and working, to turn every “though” and every “if instead” into a new version of the prototype within minutes.

A Prototype for Everyone

Thanks to AI agents, teams today can quickly build exploratory versions of the product to show to stakeholders, test micro-functionality or simulate real-world user experiences in a matter of hours. These are no longer just mockups, but interactive prototypes with high emotional fidelity.

The Beating Heart of Collaboration

In this evolution I see the essence of the **Agile Manifesto **again. From AI-generated prototypes emerge conversations, fueling ongoing dialogue between teams and stakeholders, turning any feedback into an opportunity for immediate iteration.

Even if incomplete, even if crude, these digital artifacts generate tangible and immediate value: they allow people to touch an idea, to experience it by giving value to the dominance of “working software” over documentation.

It is in “collaboration with the customer” that AI agents show their real revolution. It is no longer about presenting a predefined solution and negotiating its details, but co-creating in real time, building the experience together while discussing it. The customer becomes an active part of the creative process, no longer just the end recipient.

And when change becomes inevitable, as is often the case in complex projects, the ability to “respond to change” translates into how quickly an AI prototype can adapt, evolve, reinvent itself. What once required weeks of reprogramming can now be changed in a matter of hours, allowing teams to embrace uncertainty as a source of opportunity rather than an obstacle. Having a prototype aligned before moving to the real implementation phase within an iteration helps anticipate change.

Toward Continuous Discovery

AI agents are democratizing prototyping. Discovery is no longer an early and isolated phase, but a continuous and distributed process. It is no longer the exclusive task of the UX team, but a shared practice among designers, developers, product managers, and stakeholders.

Conclusion

Prototyping with AI agents means building to understand, creating to validate, exploring to align.
In a world where change is the norm and solutions are always temporary, the ability to prototype with speed, intelligence, and authenticity is what separates learning teams from those just trying to keep up.

GIT what’s behind your usual operations

Alberto Gianfranco Meleleo — Sun, 25 Feb 2024 18:47:51 +0000

In my career as a developer and beyond, I have been able to see how much a guy approaching this world tends to focus his energy on learning Frameworks that will make him productive quickly. This approach has a big problem, it leads to neglecting the basics, both of programming and tools.

For this reason, I have recently set myself the goal of filling these gaps.

The first step was to "tell about" GIT starting from the common use of it. Often when asked "Do you know GIT?" we get a similar answer "Yes, I use it." My opinion is that using something is not the same as knowing it.

Remote and Local Repository
first of all we need to undestand our environment structure. When we work with GIT we have a distributed code. The code is on a Remote location and to develop we need to obtain assets present on it. To do this we can proceed cloning the remote repository to our local environment.
When we do this using che simple command "clone" GIT structured our environment creating three different, foundamental, elements.

Working directory : where our working files are located.
Local index (staging area): where Git tracks and saves changes.
Local repository (.git dir): s the area that contains all of our commits

Another importat element is:

Stash:is the area where Git stores changes that we don't want to commit and push, in short, set aside.

Clone
the first step to obtain the data present on a remote repository is to execute che clone command.
Basically you can run the command defining remote repository

git clone [repository url]

in this case git prepare your environment downloading the default branch repository (usualy main) in the actual directory.

you can also use a lot of options to clone a different branch, to stored files in a different directory, and so on. You can find all options in the ufficial git documentation.

https://git-scm.com/docs/git-clone

Branch
Often, during development, it is necessary to create a local branch based on the current control branch.
To do this, you can use the "branch" command.

git branch feature/myFeature develop

https://git-scm.com/docs/git-branch

Add and Commit
When the developer creates or modifies some files, the data must be sent to the remote repository. To do this, the developer must first add them to the stage (local index) and then to the local repository.
The relative commands are:

git add [filename]
git commit -m "[commit message]"

if the dev creates a new file he has to use the "add" command to add the file in the stage, instead, when he modifies or deletes a file, the change is applied directly in the stage.

https://git-scm.com/docs/git-add
https://git-scm.com/docs/git-commit

Push
After committing, the developer must send the changes to the remote repository so that the changes are accessible to other team members. The specific command is "push".

git push <remote>
git push origin

https://git-scm.com/docs/git-push

Fetch
when other team member push modification, the developer can be need to see this infirmation without update it in his working directory. The command to do this is "fatch". It update only the Local Repository.

git fetch

https://git-scm.com/docs/git-fetch

Pull
After fetch, the developer can be update also the working directory, and the working branch, to use the new code. Simply he can run "pull". This command retrieve the data from the remote repository and store it in the working directory (and also update the local repository as fetch do)

git pull

Stash
When you need to update the code in the working directory but have some uncommitted changes, you can preserve the code by moving it to the stash area. After the pull, you can retrieve the code and apply it more recently in the working directory.
Both actions are performed by the "stash" command.

git stash save "my_stash_name"
git stash pop
git stash apply

apply command, saved stash overwrites files in the current working tree but leaves the stash history alone.
pop command restores files but then deletes the applied stash. https://git-scm.com/docs/git-stash

I hope this article is helpful in clarifying the structure of GIT