Marc-Alexandre Cartiant

At the sweet spot between Management, Digital Marketing and Engineering. Bullish about LLMs from 2022.

[Marc-Alexandre Cartiant @macartiant]

I have listed posts, thoughts, and prototypes on my personal website https://t.co/clVF3kMbuX regarding AI and automation, practical use cases, and digital transformation.

[Marc-Alexandre Cartiant @macartiant]

The Oversight Bottleneck: Why AI Code Generation Raises the Bar of Human Responsibility

We now have multiple ways to code.

We can still write every line ourselves.

We can write the structure and let the model fill in the details.

Or we can describe the intent at a high level and let successive generations of code accumulate into a working system.

But in every case, the human remains the initiator — and the final arbiter.

The same pattern is appearing in other domains that produce complex, high-stakes artifacts:

- contract drafting,
- architectural and engineering design,
- financial structuring.

The mechanism looks similar:

- A human provides intent or partial work.
- The system generates volume and complexity.

But the verification regimes are very different.

- A contract is tested in negotiation or court.
- A building is tested by gravity.
- Code is tested by compilers, test suites, production traffic, security review, and users.

So the generalization is only partial.

AI changes the economics of production across these fields.

It does not remove human accountability.

The visible limit appears when the generated artifact exceeds the human’s ability to review it meaningfully.

At that point, the old model of “generate, then review” starts to break.

The model can iterate on its own output. It can fix inconsistencies. It can refactor without being reminded of the original constraints.

That autonomy is useful — until it isn’t.

Because the person who must sign off, deploy, approve, or take legal responsibility may no longer be able to verify that the output implements the intended specification.

Responsibility does not disappear.

It becomes harder to exercise.

This is not solved by telling developers to “just read the code.”

When the codebase is large, generated quickly, and architecturally unfamiliar, full human comprehension is no longer a realistic control mechanism.

The bottleneck is no longer generation speed.

It is review and judgment capacity.

And this is the important point: the skills required for effective oversight are not fundamentally different from those required for high-quality original work.

To judge whether generated code, a contract, or a financial structure implements intent, respects constraints, avoids hidden failure modes, and remains maintainable, you still need deep expertise.

AI does not deskill the practitioner. It changes the unit at which expertise is applied.

The people who treat AI as magic that also magically solves oversight will eventually rediscover an old rule: You own what you ship.

[Marc-Alexandre Cartiant @macartiant]

I have never seen a no-code or low-code platform that can truly replace real code for genuinely complex systems.

We are closer than we were ten years ago, but one stubborn reality remains: the cost of understanding, evolving, and governing a large software artifact at scale still requires serious engineering skill and discipline.

The fantasy of fully specifying software without code is ancient. The Gang of Four era turned UML into near-religious practice: model first, code later. In theory it promised clarity and reuse. In practice, outside of database schemas (where the model is executable), those diagrams almost always became either superficial illustrations or expensive liabilities that diverged from reality the moment implementation began.

High-level diagrams can usefully sketch primary flows and occasionally follow standards. They are, however, almost always incomplete snapshots of intent rather than authoritative specifications. They are cheap to produce when someone is motivated and expensive to maintain when reality shifts. Reverse-engineering an existing codebase into clean models, or starting from models and keeping them in sync, quickly reveals the friction.

In environments that demand deep governance, that friction is only justified if the payoff in auditability or onboarding is massive. In most cases, the code itself remains the single source of truth precisely because it is executable, testable, and versioned.

We have already successfully raised the abstraction level many times. We no longer write processor instructions by hand. We trust compilers, runtimes, frameworks, and libraries. The question is not whether further abstraction is possible, but whether the next layer (visual builders, executable models, or AI-generated systems) can deliver the same combination of power, observability, and control that code currently provides.

The decisive variable is the required level of governance. In safety-critical, heavily regulated, or long-lived systems, you may need explicit traceability, formal properties, or generated artifacts with full audit trails. In those contexts, investing in stronger modeling or constrained languages can make sense.

For the majority of commercial software, however, the pragmatic answer remains the same: well-structured code, comprehensive automated tests, clear architectural decision records, ruthless review processes, and continuous integration deliver sufficient governance at lower long-term cost than heavyweight modeling approaches.

The future will not be “no code.” It will (actually it is already) be less code written by hand, with engineers operating at a higher level through AI copilot and tools that keep intent and implementation in sync automatically.

But code remains both the means of production and the ultimate artifact we must govern.

[Marc-Alexandre Cartiant @macartiant]

Fix the Input. Then Amplify.

Most organizations don't fail because they lack ambition, talent, or technology.
They fail because they amplify broken inputs:

- A vague strategy.
- A misaligned incentive system.
- Poor data.
- Unclear decision-making.
- Conflicting objectives.

Then they add more people, more budget, more process, or more AI.

The result?

They don't solve the problem. They scale it.

1. The mistake

Too many initiatives start with goals like:

- "Be more innovative."
- "Improve customer experience."
- "Leverage AI."

These sound ambitious, but they're not operational.

When objectives are fuzzy, systems optimize for activity instead of outcomes.

You get:

✅ More meetings
✅ More dashboards
✅ More automation

❌ Better decisions

2. The highest-leverage move

Before scaling anything, fix the input.

That means:

- Define the problem in observable terms.
- Clarify what success actually looks like.
- Align incentives and decision rights.
- Build feedback loops that are difficult to game.
- Eliminate objectives you cannot execute well.

This isn't strategy.

It's organizational hygiene.

And it's often the most neglected work because it isn't glamorous.

3. Where AI fits

AI is neither a savior nor an existential threat.

It's an amplifier.

When goals and constraints are clear, AI can dramatically increase speed, scale, and execution quality.

When goals are vague, AI simply produces larger volumes of confusion at greater speed.

The best human-AI systems follow a simple pattern:

- Humans define and refine the problem.
- AI scales the execution.

Conclusion: Fix the input. Then amplify.

Not because you want to move slowly.

Because it's the fastest way to move in the right direction.

The real choice isn't between ambition and caution.

It's between:
- Amplifying quality
- Amplifying dysfunction

And one of those compounds much better than the other.

[Marc-Alexandre Cartiant @macartiant]

Can I trust this AI not to deliberately mislead me, slow me down, or steer my reasoning in a hidden direction?

Today, when an AI produces a problematic answer, it is difficult to know what we are looking at:

- Is it a technical error?
- A hallucination?
- A safety mechanism?
- A political constraint?
- A commercial filter?

Or a deliberate design choice shaping what the model is allowed to say?

These things are often mixed together, but they are not the same.

A hallucination is a reliability problem.

A hidden steering mechanism is a governance problem.

And in some cases, it becomes a sovereignty problem.

We already see this clearly with some state-controlled models. Certain answers are restricted not because the model is technically unable to answer, but because it has been designed not to cross political boundaries.

That example is obvious.

The harder question is what happens when similar forms of steering are less visible, presented simply as “model behavior,” “alignment,” or “safety.”

AI reasoning is never fully neutral.

It reflects human design choices: technical, ethical, commercial, legal, and sometimes geopolitical.

So the real question is not whether AI systems are influenced.

They are.

The question is: by whom, for what purpose, and with what level of transparency?

This is why I believe the next wave of AI governance will not only focus on accuracy or benchmark performance.

It will also focus on:

- reasoning integrity
- auditability
- independence from external influence
- transparency of constraints
- resilience against political or commercial capture
- technological sovereignty

In the future, organizations may not only ask:

“Which model is the most powerful?”

They may ask:

- “Which model can we trust?”
- “Which model can we audit?”
- “Which model keeps our reasoning process under our control?”

The ability to prove that an AI system is reliable, transparent, and free from hidden external constraints may become a major competitive advantage.

More importantly, it may become a strategic necessity.

Because the real risk is not only that AI gives us wrong answers.

The deeper risk is that we no longer know who is shaping the answers we receive.

[Marc-Alexandre Cartiant @macartiant]

AI in HR Tools: From Form-Filling to Systems That Actually Help Careers

Most current “AI-powered” HR tools for career management and performance evaluations I have seen are optimizing the wrong thing.

Many of them are very good at one task: helping employees turn self-reported objectives, achievements, and development areas into polished text, suggested metrics, or ambitious-sounding goals.

That can feel productive.

But if the output still feeds into a process that managers skim, HR archives, and few people reference when making promotion, compensation, or role decisions, then we have not meaningfully improved the system.

We have simply made low-value administrative work faster.

The more important question is this: What would it take for AI-augmented HR systems to create real value for both employees and organizations?

I think three shifts matter most.

1. From self-reporting to evidence synthesis

Instead of asking employees to recreate their year from memory, AI should help synthesize verifiable signals:

Project outcomes.
Peer feedback.
Stakeholder input.
Delivery metrics.
Demonstrated skills.

The employee’s role should be to validate, contextualize, and correct the synthesis — not perform creative writing.

2. From one-sided forms to shared visibility

One of the biggest missed opportunities is giving employees and managers access to a common, appropriately permissioned view of performance signals.

Not surveillance.
Not raw activity tracking.
Not black-box scoring.

But synthesized insights such as:

- “This person consistently creates outsized impact in cross-functional projects.”
- “Multiple stakeholders mention strong execution under ambiguity.”
- “Feedback suggests a recurring development opportunity around delegation.”

When both sides can see the same evidence base, performance conversations become less subjective and more diagnostic.

3. From generic goals to development contracts

The highest-value use case is not generating better wording for objectives.

It is turning past performance data into forward-looking development recommendations.

What skills does this person need for their next step?
Which roles fit their demonstrated strengths?
What experiences would help close the gap?
What should the manager and organization commit to providing?

That changes the performance review from a backward-looking rating exercise into a forward-looking development contract.

And that is where AI can become genuinely useful.

The goal should not be to make HR forms faster to complete.

The goal should be to improve the quality, transparency, and actionability of the information that actually shapes career decisions — while keeping humans responsible for judgment, context, and accountability.

Today, many AI HR tools optimize for the appearance of innovation.

The next generation should optimize for clarity, trust, and better career conversations.

That is the version worth building.

[Marc-Alexandre Cartiant @macartiant]

@engineers_feed For those - like me - who didn't get it:
--
20 (t)
23 (w)
15 (o)
8 (h)
21 (u)
14 (n)
4 (d)
18 (r)
5 (e)
4 (d)
1 (a)
14 (n)
4 (d)
6 (f)
9 (i)
6 (f)
20 (t)
25 (y)
15 (o)
14 (n)
5 (e)
Add them all up → 251
(thanks Grok!)

[Marc-Alexandre Cartiant @macartiant]

Post co-authored with @DavidHardoon

[Marc-Alexandre Cartiant @macartiant]

I now possess sufficient empirical evidence to declare an uncomfortable truth: computers can smell fear.

Try to print a critical report at 11:47 p.m. the night before a deadline. The printer, previously silent and cooperative, suddenly begins speaking in its own ancient dialect of blinking lights and cryptic error codes. Translation: “Dream on, human.” Paper jams materialize in compartments that have no business jamming. Ink levels drop from 80% to “replace cartridge immediately” in the span of three pages.

The email server is in on the conspiracy. Messages labeled URGENT in all caps, decorated with red exclamation marks and threatening emojis, sit patiently in the inbox all day—until the exact moment you sit down to answer them. At that precise second, the server sighs, shrugs, and delivers a polite but firm error message. The more important the email, the higher the probability of digital mutiny.

And then there is the AI.

During the big demo, in front of stakeholders and polite smiles, the system performs beautifully at first. It displays “Thinking…” with an elegant progress animation. It even offers scientifically flavored reassurances about processing your request with quantum-inspired precision. The audience leans in. You allow yourself a flicker of hope.

Then it delivers the coup de grâce: “An error happened. Try again?”

Pure, refined psychological warfare.

This is Murphy’s Law 2.0 in full effect: "Any system that can fail will fail at the exact moment it will cause you the maximum possible embarrassment, delay, or financial damage."

We didn’t just add complexity to technology.
We gave it TIMING!

Machines have been granted not only processing power but also the exquisite ability to mock their creators at the worst possible moment. They can now smell desperation, deadlines, and that tiny bead of sweat forming on your forehead. That’s when they strike—with elegance, perfect comedic timing, and zero mercy.

We were losing this war from the beginning.

Before the digital age, at least the betrayals were slower and more honest. A typewriter ribbon would snap. A fax machine would eat the page. Today the betrayal is instantaneous, global, and backed by cloud infrastructure.

Yet here we are—still clicking “Retry,” still updating drivers at midnight, still pretending the machines are on our side.

They’re not. They never were.

Stay vigilant. Lower your expectations. And above all: never let the machines know you have a deadline.

[Marc-Alexandre Cartiant @macartiant]

@elonmusk You do need to ask Grok to be "severe as fuck" to get the full feedback

[Marc-Alexandre Cartiant @macartiant]

This is deep

[Derek Sivers @sivers]

@MyleneFlicka I take that same approach to programming. I want to do it, not have it done.

[Marc-Alexandre Cartiant @macartiant]

@mysteriouskat read books

[Joscha Bach @Plinz]

emergent mind

[Marc-Alexandre Cartiant @macartiant]

Even Grok is having fun with my prompts...

[Marc-Alexandre Cartiant @macartiant]

I took a photo from almost 20 years ago and asked Grok to progressively age me an additional 40 years.

The result is both amusing and terrifying.

Amusing because Grok didn’t really capture how I look today (the ultimate accuracy test).

And yet… by the end, I wouldn’t be surprised if it’s actually close.

What troubled me most is the very last frame… you’ll understand why if you watch the video.

Curious: which age looks the most realistic to you? 👀

[Marc-Alexandre Cartiant @macartiant]

Screens optimize for speed. Paper optimizes for truth. AI optimizes for leverage.

I’ve gone back to writing by hand—real paper, real pen. I’ve almost stopped buying e-books. The difference is brutal.

A screen is frictionless. You can edit forever, rearrange instantly, bail the second a sentence fights back.

Paper does the opposite.

There’s weight. There’s cost. Each word is permanent. No backspace. No undo.

Handwriting is cognitive resistance training.

Here’s the sequence almost nobody uses: Paper → AI → Network.
Paper forces depth.
AI pressure-tests it.
The network distributes it.

Once the idea survives ink (and in French, that is, my mother-tongue), I snap a photo. Seconds later AI transcribes, translates, tightens, attacks every weak joint, and hands it back sharper. Not to replace the thought—to forge it.

Use AI first and it dilutes.
Use it second and it multiplies.
That order is everything.

What separates us from machines isn’t the tool. They’ll simulate handwriting by tomorrow if they haven’t already.

It’s that we deliberately choose constraint before leverage.

Paper for incarnation.
AI for refinement.
Digital for scale.

[Marc-Alexandre Cartiant @macartiant]

@alex_buraks Glad I am not the only one facing this issue...

[Marc-Alexandre Cartiant @macartiant]

@alexxubyte Your book tackles one the biggest pain points I have currently in my career.

My full linkedin profile is here: https://t.co/KJxnvHpoQu

[Marc-Alexandre Cartiant @macartiant]

@elonmusk @Space_Station congrats Elon - you deliver 🫡🫡

[Marc-Alexandre Cartiant @macartiant]

@BillyM2k @TiffanyFong big fish

[Marc-Alexandre Cartiant @macartiant]

@engineers_feed I didn't know. 1982...fascinating