DEV Community: Julien Doussot

Prompt Debugging Is the New Stack Trace

Julien Doussot — Tue, 20 May 2025 08:46:30 +0000

What breaking AI workflows taught me about the future of engineering.

In traditional software development, when something breaks, you look at the logs. You dig into the stack trace, inspect variables, step through the debugger, isolate the bug.

In AI-powered applications, that world is gone.

When an LLM fails, there’s often no crash, no error, and no stack trace. Just a subtly wrong response. A hallucination. A weird behavior that’s technically correct but totally wrong for your user.

Debugging becomes conversational. And that changes everything.

From Code Bugs to Prompt Bugs

In our product Linkeme, we rely on prompts to:

Generate social media content
Choose relevant CTAs
Compose visual overlays

And yet, some of the most frustrating bugs we faced early on didn’t come from bad code — but from poorly constructed prompts.

For example:

"Generate a LinkedIn post for this article: 'AI agents will replace internal tools.'"

Sounds fine? Not really. The model didn’t know:

Who the target audience was
What tone to use
Whether to include hashtags, emojis, or links

The output was generic and missed the mark. So we debugged it — not with breakpoints, but with iterations.

What Prompt Debugging Looks Like

Add role and tone:

"You are a social media expert. Generate a LinkedIn post for B2B founders. Tone: bold but professional."

Add formatting instructions:

"...Include 3 lines max, use a punchy hook, and end with a CTA."

Add context examples:

"Here are 2 good posts for reference: [...]"

We iterated until the model consistently produced good results. That’s prompt debugging.

Building Tools for Prompt QA

After spending too much time manually testing prompts, we built our own tools:

Prompt versioning — Every prompt change is tracked like a commit.
Prompt test cases — Each key prompt has expected inputs and outputs.
Failure reporting — Human validators can tag a failed generation and auto-rollback to the last good version.
Monitoring with PostHog — To track usage and spot regressions.

LLM development requires building a new stack for non-deterministic outputs.

Why Prompt Debugging Is the New Core Skill

If you work with AI, prompt engineering is not a phase — it’s a new layer in your software stack.

It’s less about logic, more about guidance.
Less about syntax, more about semantics.

And it’s becoming a core engineering skill.

Final Thoughts

You don’t debug LLM apps the way you debug JavaScript or Python.
You test intentions, tweak contexts, and optimize outputs.

If that sounds frustrating — well, welcome to the future.

But once you embrace it, it’s surprisingly powerful.

Your new debugger is not a terminal. It’s a chat.

We’re exploring more around LLM-powered dev at easylab.ai — and prompt versioning is just the beginning.

How I Went From Sorting CVs to Building a Full AI-Powered SaaS With Zero Traditional Code

Julien Doussot — Fri, 09 May 2025 15:05:48 +0000

Let’s get one thing straight: I’m not a developer.

I started in telecom. Built a successful infrastructure business. Sold it. Then bought a consulting firm that placed experts into banks and corporate environments. I didn’t expect to get into software — I was managing people.

But what I didn’t expect even more was how fast I’d hit a wall.

The Pain Wasn't Technical — It Was Repetitive

By 2022, I was drowning in recruiting work. Dozens of CVs daily, Excel sheets, calendar invites, formatting issues, interview follow-ups. If you’ve ever run an operational company without a dedicated product team, you know the feeling: everything feels duct-taped.

So I started automating.

At first, I used Make.com (then Integromat). I wired together flows to read CVs, extract info, rank candidates, and trigger reminders. I used Evernote for notes, Google Sheets for storage, and GPT-3 for summaries and scoring. It wasn’t pretty, but it saved hours.

There was no front-end. Just logic.

I didn't call it “vibe coding” back then — but that's exactly what it was: orchestrating AI and tools to build without code, just intent.

Clients Started Asking Questions

By mid-2023, something strange started happening.

Clients were no longer impressed by our ability to place consultants. They were fascinated by the internal tools we were using.

“Wait — you’re doing all that without a dev team?”

That’s when I realized the software was the product.

So I gave it a name. I rebuilt it. And I prepared to commercialize it.

That’s when Linkeme was born.

From MVP to V1: Built with AI, by AI

I didn’t start with an idea. I started with a problem: "I spend too much time managing content and candidate workflows." That was it.

When I moved to productize Linkeme, I rebuilt the entire stack using:

Bolt.new for front-end UI and logic (a spinoff from StackBlitz)
Make.com for backend logic
GPT-4.1 and Claude for copywriting, parsing, and decision-making
A custom internal agent to rank post ideas
A CTA engine that adapts length/tone for each platform
A visual composition layer that auto-generates illustrations with title, subtitle, and brand overlay
Publishing logic across LinkedIn, Twitter, Instagram, Facebook — with zero manual input

Give Linkeme a URL or a topic, and it outputs brand-compliant, multi-platform content — fully automated.

Version 2.0: Scalable Infrastructure, Same Vibe

As traction grew, we scaled.

We rebuilt the architecture using serverless AWS — Lambda, Step Functions, S3. We added Chargebee for billing and made the system multi-tenant.

But we never lost the vibe coding mindset. Using Cline.dev inside VS Code, we orchestrated LLM agents to build workflows, detect edge cases, and self-refactor code.

The same AI that created content now built Linkeme itself.

What Changed for Me

Before Linkeme, I managed consultants.

Now, I run Easylab AI — an AI-native automation agency helping teams replace repetitive workflows with intelligent agents.

We build tools like:

SandraHR — automated recruitment with LLM-based analysis
Custom internal platforms using AI orchestration
Zero-code/low-code systems for SMEs that can’t afford dev teams

All with the same philosophy: no traditional code, just design, orchestration, and validation.

So, Is This The Future?

No — not for everything. But for most operational software, dashboards, internal tools, automation flows? Absolutely yes.

You describe what you want.
The agents figure out how.
You validate the result.

We don’t do pull requests anymore. We review AI output.

We don’t write frontends. We instruct layouts and flows.

And it works.

If you're building with AI, or if you want to — start with a pain, not a stack.

That’s what Linkeme was. That’s why it still works.

👉 linkeme.ai

Happy to answer questions or dive deeper into our architecture. DM open.

From Skepticism to System: How We Transitioned to Full-AI Dev.

Julien Doussot — Fri, 18 Apr 2025 15:51:58 +0000

I’ll be honest: when the idea was first proposed that we could shift all of our code production to AI, I wasn’t entirely convinced. Like many, I saw the potential in tools like Copilot and ChatGPT—but to imagine entire features, components, even products being built from end to end by AI agents? That seemed like a stretch.

And yet, here we are.

Since October 2024, we’ve been running Easylab AI on a fully AI-assisted development stack, where human engineers no longer write production code themselves. Everything we build is developed by agents, powered by LLMs like Claude 3.7 and DeepSeek GPT 4.1, orchestrated by prompt engineers, product designers, and dev strategists.

Let me walk you through how we got here—and what we’ve learned along the way.

It started with a first project: Linkeme. A SaaS we designed for SMEs, Linkeme helps automate and optimize their social media communications by combining audience insights, AI-driven scheduling, and generative content creation. We chose it because it was ambitious—but also self-contained. If it failed, no real damage. If it worked, it would prove the value of full-AI dev.

We gave it a spec, routed it through our early AI stack, and let the agents build. The first version ran… kind of. The logic was there, but fragile. Edge cases were missed, error handling was inconsistent, and the LLM misunderstood some of our intent. But despite the bugs, what struck us was the raw velocity. It took hours—not days—to get a first working version.

We iterated. Hard.

We started building internal tools to guide prompts, track agent output, inject context, and debug reasoning paths. We learned which models were good for what: Claude for logic and planning, DeepSeek for clean code generation, others for tests or documentation. We designed role-based agents, and built structured workflows around them. We enforced standards. We forced ourselves to slow down—just enough to design the orchestration layer properly.

There were failures. Some releases went sideways. There were moments where we thought, “Okay, maybe this was too much, too fast.” But each time, the lessons stuck—and the system got better.

Within weeks, we had restructured our delivery pipeline. Our engineers stopped writing components manually and instead began managing tasks as intentful orchestrators. They designed specs, prompted agents, reviewed code, validated logic, and shipped. They became system designers, reviewers, QA partners, and meta-programmers. And they got very good at it.

Today, we can say with confidence: our engineering team doesn’t just use AI—they build through AI. They operate on another level. They move faster, think bigger, and have developed a skillset that I believe will define the next decade of engineering: the ability to shape autonomous systems that build autonomously.

Is it perfect? No. We still hit edge cases. Prompting is an art, not a science. And we’ve had to invest a lot into internal tooling to keep the whole orchestration layer stable and explainable. But the benefits are undeniable.

What we’ve gained

We deliver features in 10–20% of the time it used to take
Our engineers are less fatigued and more intellectually engaged
We’ve built a scalable internal knowledge architecture through reusable agents
We’ve created a culture of systems thinking, experimentation, and speed

What’s still challenging

Prompting isn’t trivial. It requires training and intuition
LLMs hallucinate logic if instructions are vague
Multi-agent orchestration is fragile without the right sequence and fallback mechanisms
We had to build internal tools to track agent decisions and outputs

How it works in practice

A spec is written in natural language
bolt.new generates the base skeleton
The “Back-end Builder” agent expands logic and integrates with data models
Claude 3.7 refines the API logic and writes tests
A “QA Validator” agent audits edge cases and coverage
A human reviews, validates security, and deploys This entire process usually takes 1–2 days

We're still learning. Still improving. But today, I believe Easylab AI has one of the most forward-leaning dev cultures you’ll find in Europe. And it all started with a test project we were prepared to let fail.

If you’re considering a similar shift—or if you’ve already tried something like this—I’d love to hear your take. How far are you pushing AI in your own dev workflow? Where are the limits? Where are the surprises?

Let’s open the conversation.

Discover how Easylab AI builds with agents and LLMs

Check out Linkeme – our first fully AI-developed SaaS