Mert Berkan Kalkan

Simulation Systems Architect
AI-driven Simulation | Operational Analysis
Building deterministic simulation frameworks

[Mert Berkan Kalkan @mertbkalkan]

@ibx1112599 @daleverett In my setup Claude uses Codex like one of its subagents. Even when Codex edits, Claude picks up from the diff and keeps going, so there's nothing to sync. But mostly I use it for a second perspective, or to offload token-heavy work like reading what's in a screenshot.

[Mert Berkan Kalkan @mertbkalkan]

@anah_sahh Big companies will have to either downsize or produce a lot more to stay profitable.

The bottleneck is shifting from execution to AI orchestration. And small teams that figure this out can now compete with much larger companies.

[Mert Berkan Kalkan @mertbkalkan]

What does it take to build a simulation platform for unmanned systems?

Today we published our first whitepaper on N8RO: our answer so far, and the reasoning behind what we're building at Arkheon. Some of it will age well, some won't. This is where we stand in November 2026.

The short version: drone teams already have great open tools to fly a vehicle, from ArduPilot and PX4 to SITL. What's missing is a place to test the autopilot: a world around the vehicle, a run you can repeat with one thing changed, and a record of what actually happened.

And since AI is being added to everything: we think the model matters less than what's around it. In N8RO, AI agents can suggest anything, but the simulation and the vehicle decide what really happened.

AI imagines. Physics decides.

Full paper: https://t.co/8H4eaRFzC2

#UAV #Drones

[Mert Berkan Kalkan @mertbkalkan]

Introducing our latest N8RO video:

When weather changes, the mission must adapt.

See how N8RO brings changing weather conditions into mission planning, develops an adapted operational plan, and tests the proposed solution in simulation with SITL—while keeping the operator in control.

Watch here:
https://t.co/eFqRTX8bQF

Explore N8RO:
https://t.co/8H4eaRFzC2

#N8RO #DroneOperations #DroneSimulation #SITL

[Mert Berkan Kalkan @mertbkalkan]

🚀 N8RO | AI-Native Drone Operations
SIMULATE. COMMAND. OPTIMIZE.

🎬 An AI-generated cinematic CONOPS exploring drone delivery operations—from digital twin simulation to real-time operational decisions.

https://t.co/EMAJZCcnzt

#N8RO #DroneOperations #DigitalTwin

[Mert Berkan Kalkan @mertbkalkan]

"All models are wrong, but some are useful" is the line everyone remembers. But eleven years before its familiar 1987 formulation, Box had already laid out the loop it came from: build, test, confront the error, revise, repeat. I do not know how much survives without the loop.

[Mert Berkan Kalkan @mertbkalkan]

Some wait for permission. Others wait for proof.
Builders move first, align the right people, and make the future real.

[Mert Berkan Kalkan @mertbkalkan]

Cursor was my default for a while.

Then I noticed that my effective cost was higher than I expected, partly because of the service fee shown in the billing/usage breakdown. For my usage, that fee felt high.

So I switched to Claude.

Also, for my workflow, I seem to reach the result with fewer iterations in Claude. At the end of the day, that matters more to me than the editor choice itself.

[Mert Berkan Kalkan @mertbkalkan]

This is an interesting perspective.
For small-to-mid scale, isolated and fast-changing software components, code could become less of a permanent artifact and more of a temporary execution tool produced by an agent.
Maybe the key distinction will not be whether code disappears, but which parts should remain as long-term system memory and which parts can simply be generated, executed and discarded.

[Mert Berkan Kalkan @mertbkalkan]

AI engineering is leaving the notebook.

That is where the real gap begins.

Not between Python and production-oriented languages.

Between prototype thinking and systems ownership.

There is a common assumption in many AI teams:

“I design the algorithm.
Systems or software engineers will integrate it.”

Sometimes, that separation works.

But only when the algorithm comes with clear contracts, assumptions, timing expectations, state logic, resource limits, and validation criteria.

Otherwise, you are not handing over an algorithm.

You are handing over unfinished responsibility.

This is where the “it worked in Python” illusion begins.

A notebook is a comfortable place.

The data is usually static.
Memory is generous.
Timing is flexible.
Execution is controlled.
The plots look clean.

But real systems are not notebooks.

At 100 km/h, a 100 ms inference delay means the vehicle moves almost 2.8 meters before the decision even lands.

In robotics, aviation, autonomy, simulation, and defense systems, latency is not just a number on a chart.

It becomes part of the behavior.

The same applies to memory and compute.

A model that feels lightweight on a workstation may be unrealistic on an embedded target, a flight computer, a backend service, or any constrained runtime where compute, power, memory, and timing budgets are fixed.

Modern AI runtimes, compilers, accelerators, NPUs, and deployment stacks are powerful.

But they do not remove system constraints.

They only raise the expectation that engineers understand where their algorithms will actually live.

Systems engineers can integrate implementation.

They cannot integrate missing assumptions.

They cannot validate behavior that was never specified.

They cannot recover timing logic, state handling, unit consistency, or resource awareness after the fact without rework.

And rework is where serious projects quietly lose months.

In real-time systems, robotics, simulation engines, backend platforms, embedded targets, and performance-critical runtimes, an algorithm is not just an idea.

It is behavior under constraints.

A flight dynamics model does not care how elegant your notebook is.

An inference runtime does not care how clean your prototype looks.

A production service does not care that the algorithm worked once in Python.

An embedded control loop does not care that the math looked correct in isolation.

They care whether the behavior survives timing, state, latency, units, numerical stability, memory limits, determinism, and validation.

So no, every AI Engineer does not need to write production C++, C#, Java, Rust, or embedded C.

But every AI Engineer working near serious systems should have enough systems literacy to read reference logic, understand its assumptions, preserve its behavior, and adapt it responsibly into their own environment.

Because if a simple reference function with clear inputs and outputs becomes a blocker just because it is written outside your preferred language, the limitation is not the language.

It is ownership.

Python may be enough to explore the idea.

But in serious systems, you are not just producing code.

You are owning behavior under constraints.

Not because syntax is sacred.

Because behavior is.

[Mert Berkan Kalkan @mertbkalkan]

If you pull a critical piece out of a system without a backup, it doesn’t just crash — at least, not instantly. It slowly degrades.

Teams aren’t much different. When people start seeing random exits and messy rules, they stop aiming for excellence and start playing it safe.

Everything still “works,” but nowhere near what it could be.

And over time, the people who still have standards just opt out.

[Mert Berkan Kalkan @mertbkalkan]

Did AI make entrepreneurship easier?

Yes—it opened the door for everyone.

But inside, there’s no light anymore; only the hum of a crowd using the same tools.

The real difference comes from choosing the silent sign hidden in the dark.

In this age, competition isn’t technical—it's knowing which way your shadow points.

[Mert Berkan Kalkan @mertbkalkan]

I’ve come to see that leaders reveal themselves by how they handle weight.

Low-level leaders cling to every task—mistaking control for competence.
Mid-level leaders delegate tasks—but keep ownership chained to themselves.
High-level leaders delegate ownership—building others who can decide, act, and grow.

When managers are always busy, it usually isn’t a badge of honor.
It’s a sign that work isn’t distributed, trust isn’t established, and leadership hasn’t fully matured.

For me, true leadership isn’t about how much one can endure.
It’s about how much capacity one can create in others.

Because in the end, leadership is not the art of carrying more—
it’s the art of enabling more to be carried forward.

“Leadership is not measured by the weight you carry, but by the future you enable.”

[Mert Berkan Kalkan @mertbkalkan]

Bold visions rarely die from criticism.
They die when you try to define them.
What are we really building?
Who benefits?
What does success look like?

Ask the right questions—
and watch illusions vanish.
Clarity isn’t a threat. It’s a test.

[Mert Berkan Kalkan @mertbkalkan]

A colleague believes employees should sit at their desks, even if they’re not working, because “they’ll eventually do something.”

But here’s the thing:
💡 Productivity isn’t about presence—it’s about results.
Constant monitoring stifles creativity.
Autonomy and trust drive better outcomes.
Flexibility isn’t a weakness; it’s a strength.

If a manager can’t evaluate performance by results and relies solely on “looking busy” to feel satisfied, perhaps the issue isn’t with the team but with leadership itself.

What do you think? Have you ever experienced a workplace where presence mattered more than results? Share your story!

[Mert Berkan Kalkan @mertbkalkan]

True, $AVAX's capped supply will strengthen its potential as a store of value in the long run. But for mass adoption, it will need to prove itself as a medium of exchange. At the end of the day, which crypto will we use for daily groceries? And in which countries will it truly be supported?

Crypto will need to move beyond selling dreams of quick riches.

[Mert Berkan Kalkan @mertbkalkan]

Facing challenges in leadership can be tough, but staying connected and building a supportive network with peers can make a significant difference. Remember, unity and resilience pave the way for success.

[Mert Berkan Kalkan @mertbkalkan]

Does Bureaucracy Still Belong in Modern Software Engineering?
In the '80s and '90s, bureaucracy was a staple of organizational efficiency. Hierarchies and layers of approval ensured stability and control. But is this model still relevant for today’s software engineering world?

In an era defined by rapid technological advances, real-time communication, and agile development, rigid bureaucratic processes are more likely to slow progress than ensure quality. When decisions travel through multiple managerial layers, opportunities for innovation get lost in transit.

Modern software teams thrive on collaboration, transparency, and speed. Leadership today should be about accessibility and trust, not gatekeeping and bottlenecks. Direct communication between all levels empowers teams to solve problems faster and stay aligned with evolving goals.

In a world where speed and adaptability are everything, perhaps it’s time to reconsider if bureaucracy is serving us — or slowing us down.

[Mert Berkan Kalkan @mertbkalkan]

@michael_c_law Deep focus is great, but I’ll raise you one: the real superpower is effective delegation. That’s where true growth happens. 🚀