Forem: Jean-philippe Ulpiano

Why the Junior Ghost Town is our biggest threat

Jean-philippe Ulpiano — Sun, 25 Jan 2026 12:18:08 +0000

💡 TL;DR:

Blind prompting kills intuition,
Refactoring must be human-led,
Strong fundamentals matter more than ever.
The future belongs to high-impact architects who can direct intent, mentor juniors, and keep the steering wheel as AI accelerates everything.

The era of the "Keyboard Monkey" is dying.

Complexity used to be a wall. Now, it’s a choice.

I just turned a 2-week multi stack project (here!) into a 24-hour "Vibe Coding" session. By using LLMs as a force multiplier rather than a replacement. The "Keyboard Monkey" era—the age of syntax-grinding and boilerplate-battling—is officially over.

We are transitioning from typists to orchestrators, and if you aren't prepared for the "Dark Side" of this shift, you're already behind.

AI is not a replacement for human talent; it is a force multiplier that reaches its peak only in deep collaboration with us.

By Vibe Coding, I don’t mean prompting blindly—I mean rapidly iterating with an LLM while keeping architectural intent and final control firmly human.

The Velocity: 2 Weeks of Work in 24 Hours

The "vibe" isn't just about speed; it's about the removal of friction and the quality.

Boilerplate is dead: Low-value configuration that used to eat hours is now gone in seconds.
The "Skeleton" Strategy: I found that letting the LLM generate the initial architecture is incredibly powerful.
Best Practices by Default: Even in areas where I wasn't a master, the generated code followed solid design patterns I might have overlooked under a tight manual deadline.

The Dark Side

But let’s be real—this isn't a free lunch. There is a "darkness" creeping into our workflow that we must address.

1. The Death of Intuition

I noticed a dangerous reflex: the moment something broke, my first instinct wasn't to analyze the root cause—it was to describe it to the LLM.

We are trading our diagnostic intuition for prompt-response loops.
If we lose our "gut feeling" for why a system fails, we become nothing more than high-paid copy-pasters.

2. The Refactoring Trap

Vibe coding is a chainsaw, not a scalpel. When I tried to hand over the "steering wheel" to the LLM for deep refactoring or consolidation, the results were disastrous:

The code drifted,
Requirements blurred,
And I felt control slipping through my fingers.

The solution was not less AI—it was a reversal of control.

I started analyzing the code myself first, manually identifying exactly what needed to improve.
Only then did I bring in the LLM—not to "fix it," but to offer targeted suggestions on specific designs, architectures, or logic blocks.
The result of this targeted approach was impressive no matter whether I was drilling into
- the React frontend,
- the node backend,
- a DB design,
- a low-level Linux command.

By iterating on this approach, the quality didn't just improve; it compounded. This process proved a fundamental point: The collaboration between human and LLM is incredibly powerful, but it requires a very clear technical understanding to succeed.

It is not a shortcut for the lazy. For this to work, both the human and the LLM need to be operating at the highest level. You provide the surgical intent; the LLM provides the specialized execution.

3. The Requirement Paradox

Even with a crystal-clear vision, the LLM remains a "black box" of intent. It can hallucinate on even the smallest tasks, delivering a "mostly-right" application that is riddled with bugs and misses your core objectives.

Despite the leaps in model capability, the power dynamic hasn't changed: the LLM is the engine, but you must remain the steering wheel.

The Future belongs to the "High-Impact" Architect

The days of coasting by with sub optimal technical knowledge are over. To thrive in the era of Vibe Coding, you need a stronger technical foundation than ever before. You must:

Understand every line of generated code.
Anticipate side effects between the client, server, and OS.
Master the fundamentals (Linux, Architecture, Logic) to keep the LLM from veering off-course.

The shift is clear: Our jobs are moving from "typing code" to "directing intent." We are becoming orchestrators of immense complexity at an unmatched pace.

The Looming Crisis: The "Junior" Ghost Town

There is a dangerous trend emerging: the neglect of junior developers.

We see the logic being pushed by LLM CEOs—selling a dream where senior "Prompt Engineers" replace entire teams.

This is a short-sighted delusion.

LLMs are the tools of tomorrow meant to help us build a vastly more sophisticated world. Using them merely to replace developers for today’s complexity problems is missing the point entirely. It is a strategy born of investor-driven myopia—seeking maximal profits while possessing minimal vision. They aren't just optimizing; they are cannibalizing the future of technology.

I will likely be retiring in less than 15 years, followed by a massive cohort of current senior architects. If we stop hiring and training juniors now because "the AI can do the entry-level work," we are burning the bridge to the future.

By not preparing a path for the next generation of "High-Impact" developers, we aren't just killing a career path; we are killing the industry.

LLMs are trained on the output of human brilliance. If we stop cultivating new human experts, the models themselves will eventually stagnate on a loop of their own mediocrity.

We need juniors to become the masters of tomorrow, or there will be no one left to hold the steering wheel.

The Bottom Line

We are no longer defined by our ability to remember syntax or grind out boilerplate.

We are defined by our taste, our architectural judgment, and our ability to mentor the next generation in a world moving at an incredible new speed.

But don't be fooled by the fables of LLM CEOs pitching to investors; these models are stochastic, not sentient. They are inherently non-deterministic, and that is precisely why they are both incredibly powerful and dangerously unpredictable. To master them, you must stop thinking of yourself as a typist and start seeing yourself as a pilot.

Think of it like the AMP (Amplified Mobility Platform) suits in Avatar: you are sitting inside an immense, powerful machine that you can control with just a few fingers.

The machine provides the brute strength and you provide the balance, the intent, and the soul. But because it is not deterministic it can hallucinate, you must ensure each action is carefully reviewed before it is ever applied or you will lose control.

Much like the dawn of Cloud Computing, we are standing on the edge of a new frontier. When the cloud arrived, we didn't just get "faster hardware"; we unlocked new paradigms like serverless, auto-scalin, global resilience and many more at an incredible scale totally not imaginable a couple of years before.

Vibe Coding is our next "Cloud moment." It is opening a door to use cases and features so complex they haven't even been defined yet.

The "Keyboard Monkey" is dead. Long live the Human Orchestrator.

The tools have changed, the stakes have risen, and the horizon has just expanded. Now, it’s time to see what we can actually build when the impossible of yesterday becomes the baseline of tomorrow.

I’m curious how you are balancing speed vs. intuition—especially when refactoring with LLMs. Where have you been burned?

Special Thanks to Sarfraz Siddiqui for reviewing this piece and providing invaluable feedback.

📱 Your Child Is Still Awake: Raising Kids in a World of Screens and AI

Jean-philippe Ulpiano — Sun, 18 Jan 2026 12:23:00 +0000

🕰️ Behind Closed Doors - The Night Parents Don’t See

Giving children unrestricted access to the internet isn’t freedom—it’s exposure.

Phones offer parental controls, limits, and visibility. Desktop computers don’t.

No curfews.
No clear insight into when “homework” turns into hours of algorithm-driven content.

By the time we notice the impact, habits are already formed:

Fractured attention.
Shifting motivation.
Conflicts that strain trust at home.

Technology is necessary for learning—but necessity doesn’t mean surrender.

If technology is shaping our children, then that’s exactly where the solution needs to start.

⚠️ The New Frontier: Risks of Unrestricted Access

Beyond the familiar distractions of social media, we are now facing new and documented dangers in the digital landscape:

The Impact of Constant Connectivity: Research continues to highlight the grim effects of unrestricted smartphone and internet access on children, impacting mental health, sleep, and cognitive development.
The YouTube “Attention Trap”: Rapid, short-form video content is increasingly linked to reduced attention spans and hijacked reward systems, making it harder for children to focus on slower, effort-based tasks like studying.
The LLM “Empathy Gap”: Large Language Models such as ChatGPT, Gemini, and Claude introduce unique psychological risks. Experts warn of an “empathy gap”, where children over-trust AI responses or mistake simulated understanding for human intent.
Academic Erosion: Recent MIT and Stanford research suggests that over-reliance on LLMs for schoolwork can lead to “cognitive laziness,” trading long-term brain development for short-term convenience.

These risks aren’t hypothetical. They’re already here.

🦊 Introducing Firefox Manager

Firefox Manager is an open-source application designed to bring structure and boundaries back to desktop browsing.

It allows parents to manage Firefox by creating a highly regulated environment, where access is intentional, visible, and time-bound—without turning the computer into a constant source of conflict.

📸 Application Preview

Here’s a glimpse of the interface and how straightforward it is to define rules and limits:

Follow this link for a live demo: 👉 Timegate Demo Env

🚀 Quick Start: Setting Up Your Secure Environment

Ready to take back control of your household’s digital wellness? Here’s how to get started.

1. Prepare the OS

For the best balance between performance and security, I recommend installing XUbuntu on your child’s computer. It’s lightweight, stable, and makes setup significantly easier than most other Linux distributions for this application. See below some blogs to support you.
👉 Put Xubuntu on USB Flash Drive | Windows or Linux
👉 Create a bootable USB stick
👉 Create Bootable USB Media in Ubuntu Using BalenaEtcher

2. Get the Application

Clone the repository to your local machine or server:

2BlackCoffees / firefox-manager

A professional-grade parent control system for Ubuntu/Xubuntu that uses Firefox Enterprise Policies and systemd services to create a "Safe-by-Default" internet environment.

Firefox Managed Session Controller (2025)

Disclaimer: This tool is a technical aid. No software can replace active parental involvement and open communication regarding internet safety.

This project provides a robust system-wide lockdown and timer service for Firefox on Ubuntu/Xubuntu. It is specifically designed to create a "Safe-by-Default" environment for children by maintaining a strict whitelist of educational sites while providing controlled, timed access to the broader internet via a command-line interface.

🛡️ Child Safety & Protection Features

Modern technology is a double-edged sword: while access to AI and the open web is essential for digital literacy in 2026, it introduces significant risks to younger users. This tool implements a "Whitelist-Only" architecture, recognized by safety experts as the gold standard for protecting children from unvetted content.

The Challenge

While mobile devices often have robust parental controls, desktop environments (especially Linux) can be harder to secure. Research from 2024 and 2025…

View on GitHub

3. Configure Whitelists & Limits

Open Firefox Manager and define your rules:

🛡️ The Safe Zone: Add educational websites to a Whitelist. These sites remain accessible at all times and do not count against daily usage limits.
⏳ The Restricted Zone: Add high-distraction platforms or AI tools such as YouTube, ChatGPT, or Claude.
🌍 Remote “On-Demand” Access: Need to grant 15 extra minutes while you’re at work? You can authorize time from anywhere in the world via the web app, and the change applies in seconds.

4. Define a “Digital Bedtime”

Set Time Windows to protect sleep and routines. For example, block all browser activity before 8:00 AM and after 8:30 PM to ensure the computer doesn’t quietly take over the night.

Note: Because Firefox Manager is open source, you have full visibility into how your child’s data is handled. No hidden tracking. No cloud surveillance. Just local, transparent control.

🔑 Key Features

Granular Whitelisting: Define exactly which educational pages are always allowed.
Timed Access: Grant specific daily limits, for example:
- 30 minutes of YouTube
- 15 minutes of ChatGPT / Claude
Automatic Enforcement: When time runs out, access is blocked—no arguments, no negotiations.
Time Windows: Define the earliest start time and latest end time to prevent late-night browsing.

Pro Tip: You can even pre-authorize time for the next day. Access remains blocked until the next allowed window begins.

📱 Cross-Platform Management

Firefox Manager isn’t limited to the desktop. You can install it as a Progressive Web App (PWA) on:

Android
iPhone
Any modern browser

This allows you to adjust limits, grant time, or check usage remotely—no matter where you are.

🏁 Conclusion

We can’t remove technology from our children’s lives—and we shouldn’t. But we can remove chaos, invisibility, and unchecked influence.

By using open-source tools like Firefox Manager, we can give children access to the digital world they need for learning—while protecting them from the darker side of unrestricted AI, video platforms, and algorithm-driven content.

This isn’t about control.
It’s about guidance.
And it’s about showing up before the damage is done.

🤝 Community Discussion: Let’s Share Ideas

Managing digital wellness is an evolving challenge. I’ve shared my approach—fighting tech with tech—through Firefox Manager, but I’d love to hear from this community of builders and parents:

What’s your approach? Network-level blocking (Pi-hole, NextDNS), custom scripts, or behavioral rules?
Feature Ideas: What’s missing from desktop screen-time management today?
Reducing Screen Time: Beyond blocking, what strategies have actually worked in your home?

How are you protecting your family’s digital space? Share your projects, scripts, or ideas in the comments below.

Why Autogenerated Unit Tests Can Be An Anti-Pattern

Jean-philippe Ulpiano — Sat, 09 Aug 2025 07:55:05 +0000

We are all excited about the potential of Generative AI (GenAI) to boost our productivity. However, it's crucial to critically evaluate where and how we apply these tools, especially in areas like software testing. This post explores why relying solely on GenAI to generate unit tests can be an anti-pattern, ultimately undermining the very purpose of testing.

The Core Purpose of Unit Tests

Unit tests are about verifying that the code we write aligns with our intended design and discover bugs as early as possible. They force us, as developers, to clearly articulate the behavior we expect from a specific unit of code. To focus purely on the implementation details, we strategically mock dependencies. This isolation allows us to confidently assess if the code behaves as we designed it—a critical part of the development process. It's a feedback loop that solidifies understanding.

The Illusion of Green: Why GenAI-Generated Tests Can Be Misleading

Let's assume, for a moment, that a GenAI LLM can consistently produce unit tests that compile and result in a "green" build status. Does this mean our code is bug-free? Absolutely not . It simply means the LLM has crafted tests that pass, regardless of underlying issues.

Here’s where the real problem lies:

Testing the Tests, Not the Code: If we discover a bug and fix it, the GenAI-generated test will likely fail if by chance the assertion is well crafted. The natural (and dangerously flawed) response might be to simply rerun the LLM on the corrected code to regenerate a passing test. This cycle demonstrates that the tests are validating the LLM's ability to create passing tests, not the correctness of our code. They offer a false sense of security.
Weak Assertions: GenAI-generated tests often feature weak or overly general assertions. These assertions have a high probability of "sticking" even when the underlying code's behavior is flawed. It’s easy to pass a test that doesn't truly validate the logic. See below for an example.
Erosion of Trust: Historically, a suite of passing unit tests has signaled a degree of code quality and reliability. When that signal is diluted by tests designed to pass despite bugs, we lose a valuable indicator of quality and increase risk.
See an example of source code here (Source code):

See LLM generated test here:

We observe the following:

By default, many crucial code paths are not adequately exercised, leading to a false sense of security indicated by a “green” build status.
The test assertion merely verifies the presence of certain fields within a data structure, without validating the correctness of their values. This constitutes a very weak and insufficient test.

Below is another source code:

Generated test is:

We observe the following:

The test case for the test_str variable expects a Markdown-encoded table. The LLM’s failure to generate a valid test highlights a lack of clarity in the original code – valuable feedback if the generated tests are reviewed! However, without human review, this important insight would be lost.
The assertion remains weak, providing limited validation of the code’s behavior.

Is GenAI Useless for Unit Testing? Not Entirely.

Despite these concerns, GenAI isn't without value in the unit testing workflow. The most promising application lies in human-LLM collaboration:

Boilerplate Generation: LLMs excel at generating the structural boilerplate of unit tests – setting up mocks, creating test methods, and ensuring comprehensive code coverage. This can significantly reduce the tedious and repetitive aspects of test creation, combating "test fatigue."
Coverage Focus: An LLM can quickly identify untested code paths, helping ensure maximum code coverage with the framework for the test.

However, the critical step remains with the developer: We must write the assertions. We must define the specific, meaningful validations that confirm the code behaves as intended. The LLM prepares the ground; the developer ensures the seeds of quality are sown.

Below is an example how such a human LLM collaboration could happen:

Following this schema, we begin by generating an initial set of unit tests. We then measure code coverage and compare the uncovered code paths—as identified by analysis of the Abstract Syntax Tree—to those exercised by the existing tests. This information is used to prompt the LLM to generate additional tests, specifically designed to activate the missing paths with appropriate parameter values.

We consolidate each new set of tests and remeasure code coverage, repeating this process recursively until 100% coverage is achieved.

Crucially, human intervention is then applied to craft robust and meaningful assertions for each test path, ensuring that each test genuinely validates the intended behavior.

Conclusion

While GenAI offers enticing possibilities, blindly accepting autogenerated unit tests as a substitute for thoughtful, developer-driven testing is a mistake. Let’s leverage GenAI to assist us in writing better tests, not to replace the critical thinking and validation that are essential to building robust and reliable software.

LLM Future Automation

Jean-philippe Ulpiano — Sat, 24 May 2025 07:27:24 +0000

The Golden Eggs of Software Development: Why Replacing Human Developers with AI Might Not Be the Best Strategy

As I reflect on the current trend of investors pushing for automation and replacement of human skilled developers through AI, I'm reminded of the classic fable of the hen that laid the golden eggs. Are we risking the long-term benefits of software development by prioritizing short-term gains?

As a seasoned software and cloud architect, I have analyzed some facts that warrant consideration:

Meanwhile, the current layoffs and difficulty in finding new skilled developers might become even more challenging in the future

It's essential to step back and assess the situation.

The idea that we can create a Large Language Model (LLM) that can generate software as good as the best developer in the world might seem appealing, but it's a short-sighted approach. Even if LLMs could produce high-quality code, they would still be constrained by their training data and unable to surpass the capabilities of human developers.

To understand why LLMs are constrained by the data used to train them, let's dive into their basics. At their core, LLMs are statistical machines that produce coherent text by leveraging patterns and randomness. However, this approach comes with inherent constraints: they lack the nuance of human intuition, the capacity for diverse coding approaches, and the ability to seamlessly integrate new domain knowledge. The primary reason for these limitations is that LLMs can only generate responses based on the data they were trained on. As a result, their growth and evolution are directly tied to the quality and novelty of the data used to train them. If the new data doesn't introduce fresh perspectives, creativity, diversity, or domain expertise, the models will not be able to advance beyond their current capabilities, effectively capping their potential for improvement.

Furthermore, if we rely solely on LLMs, assuming LLM can generate accurate software source code, companies will struggle to differentiate themselves.

Instead, I propose we envision current LLM capabilities as a foundational seed for future technological advancements. By collaborating with humans, LLMs can generate new data under the human creativity guidance, leading to unprecedented code diversity. This closed-loop system will create a snowball effect, where new data will be generated, curated, and used to improve future models.

LLMs have the potential to unlock numerous opportunities, certainly exceeding the number of roles that may be automated or replaced in the short term. In my company, we're embracing this collaborative approach, recognizing that human developers and LLMs can work together to achieve unprecedented long-term quality and efficiency growth.

This reality is not yet achieved, however, looking in depth, performing various analysis I could realize that LLMs excel at generating human-consumable assets but require additional support or complex RAGs when creating machine-consumable assets which are very often not reliable without human verification.

Challenges and Questions are welcome