Terminal autocomplete hasn’t really evolved.

It’s still:

• prefix-based
• fragile to typos
• unaware of how you actually work

It’s fast, sure. But it’s not helpful.

The problem with terminal autocomplete

Most shells do one thing well:

👉 complete what you already started typing

That’s it.

If you type:

dokcer logs

You get nothing.

If you type:

docker rec

You also get nothing.

Even though:

• you meant docker
• you probably ran docker logs 100 times before

The shell doesn’t care.

It doesn’t learn.
It doesn’t adapt.
It just matches prefixes.

What I wanted instead

I wanted something that:

• learns from my actual command history
• fixes typos automatically
• understands intent, not just prefixes
• stays instant (no lag while typing)

So I built a different kind of autocomplete.

A better autocomplete (Agensic Autocomplete)

Instead of treating commands as static strings, I treat them as patterns.

That enables things like:

• dokcer → docker
• docker records → docker logs

And importantly:

👉 it stays local-first and fast

AI is only used as a fallback when your history isn’t enough.

Most of the time, suggestions come from:

• your own repo-aware past commands, ranked on usage
• semantic matching
• typo correction

It feels closer to an IDE than a shell.

But autocomplete wasn’t the real problem

Once I started using AI agents in the terminal (Codex CLI, Claude Code, etc…), I realized something else:

Autocomplete helps you write commands.

But it doesn’t help you understand what actually happened.

The missing layer: command provenance (Agensic Provenance)

When an agent runs commands for you, things get blurry fast.

Shell history doesn’t track commands ran by agents, it’s as if they are acting in a black box.

So I added a provenance layer.

Every command gets classified and tracked:

• HUMAN_TYPED
• AI_SUGGESTED_HUMAN_RAN
• AI_EXECUTED
• etc.

And for agent-executed commands, there’s cryptographic proof.

So instead of guessing:

👉 you get a clear, auditable timeline of what actually ran and why

Then came sessions (Agensic Sessions)

The next problem showed up quickly:

Even if you know what ran…

👉 you still can’t easily reconstruct the full session

So I added session tracking.

Now you can:

• replay entire terminal sessions
• inspect command timelines
• export runs for debugging or incident review

And the most useful feature:

Time travel for your repo

You can jump back to the exact state your repository was in at a specific moment.

Not “roughly what I remember”
Not “git reflog archaeology”

👉 the exact state tied to a session checkpoint

Putting it together

What started as “better autocomplete” turned into something else:

• autocomplete → helps you write faster
• provenance → helps you understand what happened
• sessions → help you reconstruct and debug

Because once AI agents enter the terminal:

👉 speed is no longer the bottleneck
👉 understanding is

Final thoughts

Terminal tooling hasn’t really caught up with how we work today.

We’re no longer:

• just typing commands
• just running scripts

We’re:

• collaborating with agents
• delegating execution
• moving faster than we can track

And without visibility, that breaks down quickly.

If you’re curious

I open sourced the project here:
👉 https://github.com/Alex188dot/agensic

Would love feedback, especially from people using AI agents in the terminal.

Expert Analysis: The EBM-MLP Dichotomy in Out-of-Distribution and Discontinuous Regimes

Fundamental Mechanisms and Behavioral Divergence

The divergence between Energy-Based Models (EBMs) and Multi-Layer Perceptrons (MLPs) hinges on their core mechanisms for handling variable configurations and extrapolation. EBMs associate a scalar energy to variable configurations, minimizing this energy for both inference and learning. This process inherently avoids assumptions of continuity and linearity, enabling EBMs to handle discontinuous distributions and unsampled kinks without imposing artificial structures. In contrast, MLPs rely on piecewise linear extrapolation near training data boundaries due to ReLU activation, intrinsically assuming continuity and linearity. This architectural difference manifests in distinct observable effects: EBMs exhibit an absence of spandrels in out-of-distribution (OOD) regions and robustly handle discontinuities, whereas MLPs produce spandrels and artificial kinks in OOD regions.

Critical Constraints and Their Impact

Two key constraints amplify the behavioral divergence between EBMs and MLPs:

1. Training Data Sampling: Sampled data often fails to cover all regions, particularly discontinuities or kinks. MLPs, constrained by their assumptions, impose artificial structures in unsampled regions, while EBMs avoid such assumptions, remaining agnostic to unobserved data.
2. Architectural Assumptions: MLPs are bound by assumptions of continuity and linearity, leading to spandrels and artificial kinks in OOD regions. EBMs, unencumbered by these assumptions, remain unphased by unsampled discontinuities, maintaining robustness.

Instability Points: Where Divergence Becomes Critical

The divergence between EBMs and MLPs becomes most pronounced at two instability points:

1. OOD Regions Near Training Boundaries: MLPs extrapolate linearly, forming spandrels, while EBMs do not impose structures. This results in MLPs producing overconfident errors in OOD regions, whereas EBMs remain conservative.
2. Unsampled Discontinuities or Kinks: MLPs introduce artificial kinks or linear structures, while EBMs assume no data in unsampled regions. This leads MLPs to introduce incorrect assumptions, whereas EBMs avoid imposing artificial continuity.

Underlying Physics and Logic

The behavioral differences between EBMs and MLPs are rooted in their underlying mechanics:

1. EBM Energy Minimization: The energy function in EBMs associates low energies to correct configurations and high energies to incorrect ones. This logic enables robust handling of discontinuities and unsampled regions without imposing artificial structures.
2. MLP Piecewise Linearity: ReLU activation in MLPs introduces piecewise linear behavior, leading to extrapolation near boundaries. This mechanics results in the formation of spandrels and artificial structures in OOD regions.

Analytical Pressure: Why This Matters

The unique capabilities of EBMs in handling OOD data and discontinuous distributions are not merely theoretical distinctions but have practical implications. If the field continues to rely on MLPs in scenarios where their assumptions of continuity and linearity are violated, it risks suboptimal or erroneous predictions, particularly in critical applications such as healthcare, autonomous systems, and financial modeling. Recognizing the distinct advantages of EBMs is essential for advancing machine learning techniques that prioritize robustness and reliability in uncertain or unexplored domains.

Intermediate Conclusions

1. EBMs fundamentally differ from MLPs in their handling of OOD regions and discontinuities, avoiding assumptions that lead to spandrels and artificial structures.
2. MLPs, constrained by their architectural assumptions, exhibit overconfident errors and incorrect extrapolations in OOD regions, while EBMs remain conservative and robust.
3. The divergence between EBMs and MLPs is not just theoretical but has tangible consequences for applications requiring reliable predictions in uncertain scenarios.

Final Synthesis: The Case for EBMs

The EBM-MLP dichotomy underscores the need for a nuanced understanding of model behaviors in OOD and discontinuous regimes. While MLPs remain a cornerstone of machine learning, their limitations in these areas highlight the value of EBMs as a complementary or alternative technique. By avoiding assumptions of continuity and linearity, EBMs offer a robust framework for handling complex, real-world distributions. Failing to recognize and leverage this distinction risks perpetuating suboptimal practices in critical applications. As the field advances, the unique capabilities of EBMs must be integrated into the broader machine learning toolkit to ensure reliability and robustness in an increasingly uncertain data landscape.

Comparative Analysis of Energy-Based Models (EBMs) and Multi-Layer Perceptrons (MLPs) in Handling Out-of-Distribution Data and Discontinuous Distributions

Core Mechanisms and Behavioral Divergence

The fundamental distinction between Energy-Based Models (EBMs) and Multi-Layer Perceptrons (MLPs) lies in their core mechanisms for modeling data distributions. EBMs operate by assigning a scalar energy to each variable configuration, where low energy reflects compatibility with the learned distribution. This energy minimization principle drives both inference and learning, ensuring that correct configurations are favored while incorrect ones are penalized. Critically, EBMs make no assumptions about continuity or linearity, enabling them to robustly handle discontinuous distributions and unsampled regions. In contrast, MLPs rely on piecewise linear behavior due to ReLU activations, which inherently assume continuity and linearity. This architectural choice leads MLPs to perform linear extrapolation near training data boundaries, often resulting in the formation of spandrels—unintended, overconfident predictions in out-of-distribution (OOD) regions.

Constraints Shaping Model Behavior

Several constraints amplify the behavioral differences between EBMs and MLPs. First, limited training data sampling, particularly in discontinuous or kinked regions, disproportionately affects MLPs due to their assumption-driven nature. Second, architectural assumptions play a pivotal role: MLPs enforce continuity and linearity, while EBMs remain assumption-agnostic, directly influencing their OOD handling capabilities. Third, dense querying is essential to expose these differences, especially near training data boundaries where extrapolation behaviors diverge. Lastly, a fair comparison requires equivalent model size and training data to isolate the impact of architectural differences.

Instability Points: Where Models Diverge

The divergence between EBMs and MLPs becomes most pronounced in two critical scenarios:

1. OOD Regions Near Boundaries: MLPs, due to linear extrapolation, generate spandrels that lead to overconfident errors. EBMs, by avoiding imposed structures, exhibit conservative behavior, refraining from making unwarranted predictions.
2. Unsampled Discontinuities: MLPs introduce artificial kinks or linear structures, violating the true distribution properties. EBMs, by assuming no data in unsampled regions, avoid imposing artificial continuity, aligning more closely with the underlying distribution gaps.

Internal Processes and Observable Effects

The internal processes of EBMs and MLPs directly translate into observable effects that highlight their strengths and limitations:

• Impact of Training Data on MLPs: The piecewise linear extrapolation near boundaries, driven by ReLU activations, results in the formation of spandrels in OOD regions, signaling incorrect assumptions about distribution continuity.
• Impact of Training Data on EBMs: Energy minimization without continuity/linearity assumptions leads to the absence of spandrels, demonstrating robust handling of unsampled or discontinuous regions.
• Behavior Near Discontinuities: While MLPs impose linear structures, EBMs remain agnostic to unsampled regions. This results in MLPs exhibiting artificial kinks, whereas EBMs show no imposed structures, better aligning with true distribution gaps.

System Instability and Its Implications

The system becomes unstable in regions where:

• Training data is sparse or absent, particularly near discontinuities or kinks.
• MLPs extrapolate linearly, leading to spandrels and overconfident errors in OOD regions.
• EBMs underfit due to insufficient data but avoid imposing artificial structures, maintaining conservatism.

These instability points underscore the critical trade-offs between the two models. MLPs, while powerful in interpolative regimes, falter in extrapolative scenarios due to their assumption-driven nature. EBMs, though potentially underfitting with limited data, offer a more robust alternative by avoiding unwarranted assumptions.

Physics/Mechanics/Logic of Processes

The behavioral differences between EBMs and MLPs are rooted in their underlying mechanics:

• EBM Energy Minimization: Low energy for correct configurations ensures robust inference, while high energy for incorrect configurations prevents overfitting.
• MLP Piecewise Linearity: ReLU activation enforces linear segments, leading to extrapolation errors in OOD regions.
• Assumption-Driven Behavior: MLPs’ continuity/linearity assumptions introduce artifacts, whereas EBMs’ agnosticism avoids such issues.

Intermediate Conclusions and Analytical Pressure

The comparative analysis reveals that EBMs and MLPs represent fundamentally different approaches to modeling data distributions. EBMs, with their assumption-agnostic nature, offer distinct advantages in handling OOD data and discontinuous distributions, making them a valuable alternative to MLPs in scenarios where robustness is paramount. If the unique capabilities of EBMs remain unrecognized, the field risks perpetuating the use of MLPs in applications where their assumptions lead to suboptimal or erroneous predictions, particularly in critical domains such as healthcare, finance, and autonomous systems. Recognizing and leveraging the strengths of EBMs is essential to advancing the robustness and reliability of machine learning models in real-world applications.

Expert Analytical Section: EBM vs. MLP Behavior in OOD and Discontinuous Distributions

Fundamental Mechanisms and Their Implications

The divergence in behavior between Energy-Based Models (EBMs) and Multi-Layer Perceptrons (MLPs) in handling out-of-distribution (OOD) data and discontinuous distributions stems from their core mechanisms. EBMs associate a scalar energy with variable configurations, where low energy signifies compatibility with the learned distribution. This energy minimization framework allows EBMs to remain agnostic to unsampled regions, avoiding the imposition of artificial structures. In contrast, MLPs, with their ReLU activations, exhibit piecewise linear behavior, leading to linear extrapolation near training data boundaries. This extrapolation results in the formation of spandrels—unintended, overconfident predictions in OOD regions.

Causal Link: The assumption-driven nature of MLPs (continuity and linearity) directly causes the introduction of artificial kinks or linear structures in unsampled regions, while EBMs’ agnosticism prevents such artifacts. This fundamental difference in handling discontinuities underscores the distinct value of EBMs in scenarios where data distributions are inherently discontinuous or sparsely sampled.

Constraints Shaping Behavioral Differences

Several constraints amplify the behavioral divergence between EBMs and MLPs:

• Training Data Sampling: Limited coverage of the true distribution, especially near discontinuities, disproportionately affects MLPs due to their reliance on continuity and linearity assumptions.
• Architectural Assumptions: MLPs enforce continuity and linearity, whereas EBMs remain assumption-agnostic, allowing them to better handle discontinuous distributions.
• Dense Querying: Essential to expose behavioral differences near training data boundaries, revealing MLPs’ spandrels and EBMs’ conservative behavior.
• Fair Comparison: Equivalent model size and training data ensure that observed differences are attributable to architectural and mechanistic distinctions rather than external factors.

Intermediate Conclusion: The constraints highlight that MLPs’ performance degrades more significantly in OOD and discontinuous regions due to their inherent assumptions, while EBMs maintain robustness by avoiding such assumptions.

Instability Points and Observable Effects

Instability in both models manifests in specific regions:

• OOD Regions Near Boundaries:
  • Impact: MLPs exhibit spandrels and overconfident errors due to linear extrapolation.
  • Internal Process: Piecewise linearity in MLPs leads to unintended predictions in OOD regions.
  • Observable Effect: Profusion of spandrels in MLP queries, contrasted with conservative EBM behavior.

• Unsampled Discontinuities:

  • Impact: MLPs introduce artificial kinks or linear structures, while EBMs avoid imposing continuity.
  • Internal Process: MLPs assume continuity, filling gaps with linear extrapolations; EBMs assume no data in unsampled regions.
  • Observable Effect: Artificial kinks in MLPs vs. absence of imposed structures in EBMs.

Causal Link: The internal processes of MLPs and EBMs directly determine their observable effects in OOD and discontinuous regions. MLPs’ assumptions lead to artifacts, while EBMs’ agnosticism ensures conservative, artifact-free behavior.

System Instability and Analytical Pressure

Instability occurs in regions with:

• Sparse or absent training data near discontinuities.
• MLP linear extrapolation leading to spandrels.
• EBM underfitting due to insufficient data but no artificial structures.

Analytical Pressure: If the unique capabilities of EBMs remain unrecognized, the field may continue to rely on MLPs in scenarios where their assumptions of continuity and linearity lead to suboptimal or erroneous predictions. This is particularly critical in applications requiring robust OOD handling, such as healthcare diagnostics or autonomous systems, where errors can have severe consequences.

Mechanics Driving Behavioral Divergence

• EBM Energy Minimization: Low energy for correct configurations ensures robust inference; high energy for incorrect configurations prevents overfitting.
• MLP Piecewise Linearity: ReLU activation enforces linear segments, causing extrapolation errors.
• Assumption-Driven Behavior: MLPs introduce artifacts due to continuity/linearity assumptions; EBMs avoid artifacts through agnosticism.

Final Conclusion: The comparative analysis underscores that EBMs offer a fundamentally different and valuable learning technique, particularly in handling OOD data and discontinuous distributions. Recognizing and leveraging EBMs’ unique capabilities can mitigate the risks associated with MLPs’ assumption-driven behavior, advancing the field toward more robust and reliable models.

Comparative Analysis of Energy-Based Models (EBMs) and Multi-Layer Perceptrons (MLPs) in Handling OOD and Discontinuous Distributions

Fundamental Mechanisms and Behavioral Divergence

The core distinction between Energy-Based Models (EBMs) and Multi-Layer Perceptrons (MLPs) lies in their foundational mechanisms for modeling distributions. EBMs associate a scalar energy with variable configurations, where low energy signifies compatibility with the learned distribution. This framework drives both inference and learning through energy minimization, inherently avoiding assumptions of continuity or linearity. In contrast, MLPs rely on ReLU activations, which induce piecewise linear behavior and extrapolation near training data boundaries. This intrinsic assumption of continuity and linearity leads to the formation of spandrels—overconfident, unintended predictions in out-of-distribution (OOD) regions.

Mechanisms in Detail

• Energy-Based Models (EBMs):
  • Associate a scalar energy to variable configurations, where low energy indicates compatibility with the learned distribution.
  • Inference and learning are driven by energy minimization, avoiding assumptions of continuity or linearity.

• Multi-Layer Perceptrons (MLPs):

  • Utilize ReLU activations, leading to piecewise linear behavior and extrapolation near training data boundaries.
  • Intrinsic assumptions of continuity and linearity result in spandrel formation and artificial structures in OOD regions.

Impact Chains: From Internal Processes to Observable Effects

The behavioral differences between EBMs and MLPs manifest through distinct impact chains, linking internal processes to observable effects in OOD regions and discontinuous distributions.

MLP Spandrel Formation

• Impact: Incorrect assumptions about the underlying distribution in OOD regions.
• Internal Process: Piecewise linear extrapolation near boundaries due to ReLU activations.
• Observable Effect: Spandrels (overconfident, unintended predictions) in OOD regions.

EBM Robustness to Discontinuities

• Impact: Avoidance of artificial structures in unsampled regions.
• Internal Process: Energy minimization framework remains agnostic to unsampled data.
• Observable Effect: Conservative behavior in OOD regions, no spandrels.

System Instability Points: Where Differences Amplify

The divergence in behavior between EBMs and MLPs becomes particularly pronounced at specific system instability points, highlighting the limitations of MLPs and the robustness of EBMs.

OOD Regions Near Boundaries

• MLPs exhibit linear extrapolation, forming spandrels and overconfident errors.
• EBMs maintain conservative behavior, avoiding unwarranted predictions.

Unsampled Discontinuities

• MLPs introduce artificial kinks or linear structures via extrapolation.
• EBMs avoid imposing continuity, aligning with true distribution gaps.

Mechanics and Logic: Underpinning the Behavioral Divide

The contrasting behaviors of EBMs and MLPs are rooted in their distinct mechanics and logic, which dictate how they handle uncertainty and extrapolation.

EBM Energy Minimization

• Low energy for correct configurations ensures robust inference.
• High energy for incorrect configurations prevents overfitting.

MLP Piecewise Linearity

• ReLU activation enforces linear segments, causing extrapolation errors.
• Assumptions of continuity/linearity introduce artifacts in OOD regions.

Constraints Amplifying Behavioral Differences

Several constraints exacerbate the behavioral differences between EBMs and MLPs, particularly in scenarios involving limited or discontinuous data.

• Training Data Sampling: Limited coverage, especially near discontinuities, disproportionately affects MLPs.
• Architectural Assumptions: MLPs enforce continuity/linearity; EBMs remain assumption-agnostic.
• Dense Querying: Essential to expose differences near training data boundaries.
• Fair Comparison: Equivalent model size and training data ensure differences stem from architecture/mechanisms.

Typical Failures and Their Implications

The failures of MLPs and the conservative behavior of EBMs in OOD regions underscore the critical importance of recognizing their distinct capabilities.

• MLPs form spandrels in OOD regions due to piecewise linear extrapolation.
• MLPs place artificial kinks in unsampled regions, even when the true distribution is discontinuous.
• EBMs may underfit in regions with insufficient training data but do not impose artificial structures.

Intermediate Conclusions and Analytical Pressure

The comparative analysis reveals that EBMs fundamentally differ from MLPs in their handling of OOD data and discontinuous distributions. While MLPs suffer from spandrel formation and artificial structures due to their assumptions of continuity and linearity, EBMs exhibit conservative behavior, avoiding unwarranted predictions. This distinction is not merely academic; it has profound implications for applications requiring robust OOD handling, such as healthcare, autonomous systems, and financial modeling. If the unique capabilities of EBMs remain unrecognized, the field risks perpetuating reliance on MLPs in scenarios where their assumptions lead to suboptimal or erroneous predictions, potentially with catastrophic consequences.

Final Synthesis: The Distinct Value of EBMs

Energy-Based Models (EBMs) represent a distinct and valuable learning technique, particularly in scenarios involving OOD data and discontinuous distributions. Their energy minimization framework, agnostic to assumptions of continuity or linearity, ensures conservative behavior in unsampled regions, avoiding the spandrels and artificial structures characteristic of MLPs. Recognizing and leveraging the unique capabilities of EBMs is essential for advancing machine learning in critical applications where robustness to OOD data is paramount.

Expert Analysis: Unraveling the Behavioral Divergence of EBMs and MLPs in Out-of-Distribution Scenarios

Core Mechanisms Driving Divergence

The fundamental differences between Energy-Based Models (EBMs) and Multi-Layer Perceptrons (MLPs) stem from their core operational principles. EBMs leverage energy minimization, associating a scalar energy with variable configurations. This mechanism ensures that inference and learning prioritize low-energy states for correct configurations while penalizing incorrect ones with high energy. Critically, this approach avoids assumptions of continuity or linearity, providing a more flexible framework for modeling complex distributions. In contrast, MLPs rely on piecewise linearity due to ReLU activations, which, while efficient, introduce inherent limitations. Near training data boundaries, MLPs exhibit linear extrapolation, leading to the formation of spandrels—unintended, overconfident predictions in out-of-distribution (OOD) regions. This divergence in mechanisms sets the stage for distinct behavioral patterns under OOD conditions.

Causal Chains: From Mechanism to Observable Effect

The causal pathways underlying the divergence between EBMs and MLPs can be distilled into two key chains:

1. MLP Spandrel Formation: Impact → Internal Process → Observable Effect

Limited training data near boundaries → ReLU-induced piecewise linear extrapolation → Spandrels in OOD regions with overconfident predictions. This chain highlights how MLPs, constrained by their linear extrapolation, generate artifacts in unsampled regions, undermining their reliability.

1. EBM Robustness: Impact → Internal Process → Observable Effect

Absence of training data in unsampled regions → Energy minimization agnostic to unsampled data → Conservative behavior, no spandrels in OOD regions. EBMs, by avoiding assumptions about unsampled data, maintain stability and refrain from unwarranted predictions.

System Instability Points: Where Divergence Manifests

The divergence between EBMs and MLPs becomes particularly pronounced at two critical instability points:

1. OOD Regions Near Boundaries:

MLPs exhibit instability due to linear extrapolation, forming spandrels that lead to overconfident and erroneous predictions. In contrast, EBMs remain stable, avoiding unwarranted predictions by maintaining conservative behavior.

1. Unsampled Discontinuities:

MLPs introduce artificial kinks via linear extrapolation, imposing continuity where none exists. EBMs, by avoiding assumptions of continuity, align more closely with true distribution gaps, preserving the integrity of the model.

Mechanics Amplifying Divergence

The divergence between EBMs and MLPs is further amplified by specific mechanics:

1. EBM Energy Minimization:

Low energy for correct configurations ensures robust inference, while high energy for incorrect configurations prevents overfitting. This dual mechanism underpins EBMs’ ability to handle OOD data conservatively.

1. MLP Piecewise Linearity:

ReLU activation enforces linear segments, leading to extrapolation errors. Assumptions of continuity and linearity result in OOD artifacts, highlighting MLPs’ limitations in complex scenarios.

Constraints Amplifying Differences

Several constraints exacerbate the differences between EBMs and MLPs:

1. Training Data Sampling:

Limited coverage, especially near discontinuities, disproportionately affects MLPs due to their reliance on continuity and linearity. EBMs, being assumption-agnostic, are less susceptible to such limitations.

1. Architectural Assumptions:

MLPs enforce continuity and linearity, while EBMs remain assumption-agnostic. This fundamental difference in architecture drives their distinct behaviors in OOD regions.

1. Dense Querying:

Exposes MLP spandrels and EBM conservative behavior near boundaries, providing empirical evidence of their divergence under rigorous testing.

1. Fair Comparison:

Equivalent model size and training data ensure that observed differences stem from architectural and mechanistic disparities, rather than external factors.

Key Failures and Implications

The failures of MLPs and EBMs underscore their distinct strengths and limitations:

1. MLPs:

Prone to spandrels in OOD regions and artificial kinks in unsampled discontinuities. These failures highlight the risks of relying on MLPs in scenarios requiring robust OOD handling.

1. EBMs:

May underfit with insufficient data but avoid artificial structures. While EBMs may require more data to achieve optimal performance, their conservative behavior in OOD regions makes them a valuable alternative in critical applications.

Intermediate Conclusions and Analytical Pressure

The comparative analysis reveals that EBMs and MLPs diverge fundamentally in their handling of OOD data and discontinuous distributions. MLPs, constrained by their piecewise linearity and assumptions of continuity, exhibit instability and generate artifacts in OOD regions. In contrast, EBMs, through energy minimization and assumption-agnosticism, maintain robustness and avoid unwarranted predictions. This divergence is not merely theoretical but has practical implications: if the unique capabilities of EBMs remain unrecognized, the field may continue to rely on MLPs in scenarios where their assumptions lead to suboptimal or erroneous predictions, particularly in critical applications such as healthcare, autonomous systems, and financial modeling. Recognizing and leveraging the distinct strengths of EBMs is essential for advancing the robustness and reliability of machine learning models in real-world scenarios.

Code review for AI-generated code is different. A pull request can look syntactically perfect, pass all local tests, and still be wrong in a way that is hard to notice.

Our review habits, built over years of reading code written by other people, are not prepared for this. We are used to looking for logic errors or style issues. What changes now is that AI can generate hundreds of lines of code that look correct at first glance, but were built on the wrong assumptions.

This changes where the bottleneck in software development sits. Writing code is no longer the slowest part. Verifying what was generated is.

When a developer can generate large volumes of code, the reviewer’s job shifts from fixing mistakes to validating intent. The cost of a superficial review changes as well. It stops being a small bug and can become an architectural flaw, a security risk, or a performance issue that only appears in production.

The costs of trusting AI-generated code

The immediate productivity gains from AI are clear. What comes after is not always. We are starting to see new types of problems in code that looks correct at first glance, but was built with a fragile or incorrect understanding of the system.

Ignoring failures in AI outputs

AI-generated code often looks complete. It generates functions with docstrings, adds basic error handling, and follows the general syntax of the codebase. At first glance everything looks right, but important details may be missing.

The code is usually written for a generic problem, not for our specific operational context. It may also lack the extra checks that a more experienced engineer would normally add based on experience. For example, it might not consider the case where a downstream service returns a malformed object or times out under load, because those failures are specific to our system, not to the training data. The generated code might even include a `try/catch` block for a network failure, but it will not validate the payload of a successful but corrupted response.

Another common issue is the introduction of obscure or non-standard libraries. An AI model may solve a problem using a niche package it saw in training data, adding a new maintenance burden and a new security surface without the developer noticing. The code works, but now the team is responsible for a dependency they never chose.

Why current code review processes fail

Our code review practices were built around one assumption: there is a human author whose reasoning can be questioned. We review code by looking at logic and maintainability, trusting that the author has a mental model of the system. AI-generated code breaks that assumption.

The illusion of correctness

The biggest challenge is that AI code looks correct. Often it is cleaner and more consistent in style than code written by a junior developer. That aesthetic can put reviewers into a false sense of security. We look for bugs that are obvious, but miss the ones that are strategic.

An AI can generate a perfectly functional data transformation script. The reviewer confirms that it works with the sample data. What goes unnoticed is that the script loads the entire dataset into memory, a solution that works with a test file of 100 records but will crash the server when it runs against the production database with 10 million records. The code is not technically buggy, but it is operationally unviable.

This gets worse when the code contains many repeated sections. An AI can produce a 200-line controller that appears to follow the team’s REST patterns. Somewhere inside that code there may be a direct database query bypassing the service layer and its validation logic.

A human reviewer, seeing familiar patterns, may move quickly through the code and miss the architectural violation. There is no authorial intent to question, only an output to validate. You cannot trace the machine’s “reasoning” because it does not exist.

Ignoring security and performance regressions

AI models are trained on public code, including examples with known vulnerabilities and inefficient patterns. Because of that, they can repeat those solutions without evaluating the impact they introduce.

A 2021 Stanford study showed that developers using AI assistants were more likely to write insecure code than those who did not use them.

AI may suggest a deprecated encryption algorithm because it appeared in older training data. It may generate code vulnerable to a regular expression denial of service attack (ReDoS) by suggesting a complex regex pattern copied from a public forum. These are not simple mistakes. They are inherited vulnerabilities that linters and basic tests often fail to detect.

Performance regressions are also common and difficult to identify. AI tends to solve the immediate problem without considering the performance impact on the system as a whole. It may generate a solution that processes items in a list using nested loops, resulting in O(n²) complexity. This passes a unit test with 10 items but nearly stops the application with 10,000.

A human developer, with context about the system’s scale, would probably avoid this. AI does not have that context.

The same happens with error handling. In one function, the AI may use exceptions based on training examples. In another, it may return null or error codes, creating inconsistent behavior and a more fragile system.

Adapting code review for the AI era

To deal with these new risks, we need to shift the focus of code review from code correction to code verification. The question becomes: “Does this code do the right thing, for the right reasons, within the constraints of our system?” Every block of AI-generated code should be treated as if it came from a new developer who has no idea how your project works.

Prioritize intent over syntax

The review process needs to start before you look at the code. The first questions from the reviewer to the person who created the change should be: “What prompt did you use exactly?” and “What problem were you trying to solve?” This reframes the review around what the code is supposed to do.

First, verify whether the generated code actually solves the intended problem. It is common for AI to solve a similar but subtly different problem. The solution may be correct for the prompt but wrong for the business requirement.

Next, check whether the AI implementation fits into the system’s architecture. If the task was to add a simple validation rule, did it correctly modify an existing service, or did it generate a new class and fragment the logic?

Finally, mentally trace the data flow. In any non-trivial function, follow the data from input to output. What happens if an input is null? If a string is empty or contains unusual characters? If a network call fails? This deliberate tracing forces deeper analysis than a simple read-through.

A checklist for reviewing AI-generated code

To make this systematic, teams should adopt a verification-focused checklist for any pull request that contains a large amount of generated code. This moves the review away from subjective judgment and into a structured process.

• Does it understand our business domain? AI has no domain context and will fill gaps with generic assumptions. For example, did it assume a user has only one email address when our system allows several?
• Are the tests actually good? If the AI generated the tests, do they only cover the happy path? AI-generated tests are a starting point, but they rarely cover edge cases or failure modes specific to your system. The expectation for test coverage in AI-generated code should be higher, not lower.
• Is it secure? Treat the code as untrusted input. Did it introduce new dependencies, and were they evaluated? Does it handle user input safely? Does it use approved cryptographic libraries?
• Is it efficient? What is the algorithmic complexity of the generated functions? Does it access data inside a loop? Is it memory efficient? The reviewer is now also responsible for the performance analysis the generator ignored.
• Can a human maintain this? Is the code easy to understand? Did the AI choose an algorithm that is more complicated than necessary? Is the code documented to explain why it works this way, not only what it does? The person who used the prompt needs to be able to explain the output. If they cannot, do not merge it.
• Does it follow the project’s standards? AI does not know your specific architectural standards, preferred libraries, or error-handling strategies. The reviewer needs to make sure those standards are respected, checking whether the generated code integrates well with the rest of the system instead of introducing inconsistent logic.

This approach demands more from the reviewer. The reviewer’s role stops being just checking style or syntax. They need to understand whether the code actually makes sense within the system.

Otherwise, the codebase begins to accumulate subtle mistakes and problems that only appear later in production.

The speed of AI code generation is a major advantage, but it only works with strong code review processes.

The digital world as we know it rests on a mathematical foundation that has remained largely unchallenged for decades. Every secure connection you make, from online banking to encrypted messaging, relies on cryptographic algorithms that protect your data from prying eyes. But beneath this veneer of security, a storm is brewing. Quantum computers, once relegated to the realm of theoretical physics, are advancing at a pace that threatens to unravel the very fabric of our digital security infrastructure.

The Mathematics That Protect Us

To understand the quantum threat, we must first appreciate what makes our current encryption systems work. Modern cryptography relies on what mathematicians call “computational hardness assumptions” – problems that are theoretically possible to solve but practically impossible given current computing capabilities.

The RSA algorithm, named after its creators Rivest, Shamir, and Adleman, has been the workhorse of public-key cryptography since 1977. Its security rests on a deceptively simple premise: factoring large numbers is extraordinarily difficult. While multiplying two prime numbers together is trivial, reversing that operation to find the original primes becomes exponentially harder as the numbers grow larger. A 2048-bit RSA key would require classical computers thousands of years to factor using the most efficient algorithms known today.

Similarly, Elliptic Curve Cryptography (ECC) derives its security from the elliptic curve discrete logarithm problem. ECC offers equivalent security with smaller key sizes compared to RSA, making it particularly valuable for resource-constrained environments like mobile devices and Internet of Things (IoT) systems.

Symmetric encryption algorithms like the Advanced Encryption Standard (AES) face a different challenge. Rather than mathematical factorization, their security relies on the sheer size of their key space. AES-256, the gold standard for symmetric encryption, offers 2^256 possible keys – a number so vast that brute-force attacks are computationally infeasible.

Enter the Quantum Realm

In 1994, mathematician Peter Shor published a paper that would eventually send shockwaves through the cryptographic community. Shor’s algorithm, designed to run on a quantum computer, could factor large integers exponentially faster than any classical algorithm. What would take traditional supercomputers millennia could potentially be accomplished by a sufficiently powerful quantum machine in a matter of hours or days.

The implications were profound. Shor’s algorithm doesn’t merely offer a speedup – it fundamentally changes the computational complexity of factoring from exponential to polynomial time. This means that RSA and ECC, the cornerstones of modern public-key infrastructure, would become completely vulnerable once quantum computers reach sufficient scale.

But Shor’s algorithm is not the only quantum threat. In 1996, Lov Grover developed another quantum algorithm that poses risks to symmetric encryption. Grover’s algorithm provides a quadratic speedup for searching unsorted databases, which translates to effectively halving the key length of symmetric ciphers. AES-256 would offer only 128-bit equivalent security under quantum attack – still formidable, but no longer the impenetrable barrier it once seemed.

The Harvest Now, Decrypt Later Strategy

Here is where the timeline becomes deeply concerning. We do not need to wait for quantum computers to become widely available before the damage begins. Sophisticated adversaries are already executing what cybersecurity professionals call “Harvest Now, Decrypt Later” (HNDL) attacks.

The strategy is elegantly simple and terrifyingly effective. Threat actors intercept and store encrypted data today, knowing they cannot yet decrypt it. They simply wait, maintaining vast archives of captured communications, financial records, classified documents, and personal information. When quantum computers eventually mature, they will unlock these treasure troves of data, revealing secrets that their owners believed were permanently protected.

Major cybersecurity agencies worldwide have identified HNDL as a critical and immediate threat. The U.S. Department of Homeland Security, the UK’s National Cyber Security Centre , the European Union Agency for Cybersecurity, and the Australian Cyber Security Centre have all issued guidance based on the premise that adversaries are actively harvesting encrypted data with future decryption in mind. For data with long-term value – government secrets, intellectual property, medical records, financial information – the vulnerability exists not in some distant future when quantum computers arrive, but right now, in this moment, as adversaries systematically archive encrypted transmissions.

The Timeline: How Much Time Remains?

Predicting the arrival of “Q-Day” – the moment when quantum computers can break practical encryption – is fraught with uncertainty. The challenge involves not merely building quantum computers, but building quantum computers with enough error corrected qubits to run Shor’s algorithm at meaningful scales.

Current quantum processors from companies like IBM, Google, and IonQ operate with a few hundred physical qubits. Breaking RSA-2048 would likely require millions or even billions of error-corrected qubits – a staggering engineering challenge that involves not just scaling up qubit counts, but dramatically improving error rates and coherence times.

Yet the timeline is shortening. Gartner has projected that RSA and ECC could become unsafe by 2029 and potentially broken by 2034. Other estimates suggest 2048-bit RSA could be vulnerable by the early 2030s. Conservative researchers suggest 15 to 20 years may still be needed, but breakthroughs in quantum error correction could dramatically accelerate these timelines.

The consensus among experts is clear: cryptographically relevant quantum computers will likely emerge within the next two decades, and possibly much sooner. Organizations that wait for definitive proof before acting may find themselves catastrophically exposed.

Post-Quantum Cryptography: The Race for Solutions

Recognizing the existential threat posed by quantum computing, the National Institute of Standards and Technology (NIST) launched an ambitious program in 2016 to standardize post-quantum cryptographic algorithms. After eight years of rigorous evaluation involving the global cryptographic community, NIST released its first set of standards in August 2024.

The standardized algorithms – CRYSTALS-Kyber (Key Encapsulation Mechanism (KEM) ) for key encapsulation, CRYSTALS Dilithium(Renamed as Module-Lattice-Based Digital Signature Algorithm (ML-DSA)) for digital signatures, and SPHINCS+ as a hash-based signature alternative – represent a new generation of cryptographic primitives designed to resist both classical and quantum attacks. These algorithms rely on mathematical problems that appear resistant to quantum speedups, including lattice-based cryptography, code-based cryptography, and hash-based signatures

Lattice-based cryptography, in particular, has emerged as a leading candidate for postquantum security. These schemes derive their hardness from problems like Learning With Errors (LWE) and its variants, which remain difficult even for quantum computers. The mathematical structures involved offer not only resistance to quantum attacks but also practical efficiency for real-world deployment.

However, the standardization process has not been without setbacks. During evaluation, two previous candidate algorithms were compromised – one broken in under an hour. These failures underscore the importance of rigorous testing and the challenges of developing cryptographic systems that must remain secure for decades against adversaries who may eventually possess quantum capabilities.

Quantum Key Distribution: A Complementary Approach

While post-quantum cryptography offers software-based solutions, Quantum Key Distribution (QKD) provides a fundamentally different approach to secure communication. QKD leverages the principles of quantum mechanics itself to establish secure keys between parties.

The security of QKD rests on physical principles rather than computational assumptions. Any attempt to eavesdrop on a quantum communication channel necessarily disturbs the quantum states being transmitted, revealing the presence of an attacker. This offers information-theoretic security – protection that does not depend on the computational limitations of adversaries.

However, QKD faces significant practical limitations. Current implementations require specialized hardware and are limited by distance constraints and transmission losses. While QKD offers compelling security properties for specific high-value applications, it is unlikely to replace cryptographic solutions for general-purpose communication in the near term.

What Organizations Must Do Now ?

The window for orderly transition is narrowing. Organizations that delay action risk finding themselves in a crisis situation, forced to implement rushed migrations under the threat of imminent quantum capabilities.

Conduct a Cryptographic Inventory

The first step is understanding your current exposure. Organizations must catalog all cryptographic implementations across their infrastructure, identifying where RSA, ECC, and other vulnerable algorithms are used. This inventory should encompass not only internally developed systems but also third-party software, cloud services, and vendor products.

Develop a Migration Roadmap

With inventory in hand, organizations should develop prioritized migration plans. High value assets and long-lived data deserve immediate attention. Systems that handle sensitive information with extended confidentiality requirements – government classified data, healthcare records, financial systems – should be prioritized for early migration.

Embrace Crypto Agility

Organizations should design their systems for cryptographic agility – the ability to swap algorithms without fundamental architectural changes. This principle, sometimes called “cryptographic agility,” ensures that future algorithm updates can be deployed quickly and efficiently. Avoid hard-coding specific algorithms or key sizes; instead, build abstraction layers that allow for seamless transitions.

Test Post-Quantum Solutions

Begin pilot implementations of NIST-standardized post-quantum algorithms in noncritical systems. This hands-on experience will reveal integration challenges, performance impacts, and interoperability issues before they become critical concerns. Many vendors are already releasing post-quantum capable products; early adopters can provide valuable feedback and shape the development of quantum-resistant solutions.

Address the HNDL Threat

For the most sensitive data, consider the Harvest Now, Decrypt Later threat model. Data with long confidentiality requirements should be protected with quantum-resistant algorithms immediately, even if broader infrastructure migration takes longer. Some organizations are implementing hybrid encryption schemes that combine classical and post-quantum algorithms, providing defense in depth against both current and future threats.

The Countdown Continues

We stand at an inflection point in the history of digital security. The mathematical foundations that have protected our communications for decades are facing an existential threat from an entirely new paradigm of computing. The quantum countdown is not a distant concern – it is a present reality that demands immediate action.

The good news is that solutions exist. The cryptographic community has risen to the challenge, developing post-quantum algorithms that can protect our digital infrastructure well into the quantum era. NIST’s standardization efforts have provided a roadmap for the transition ahead.

What remains is the hard work of implementation. Organizations must move beyond awareness to action, beginning the systematic process of inventorying their cryptographic dependencies, planning their migrations, and building the crypto-agile systems that will carry them through the quantum transition.

The adversaries are already harvesting. Every day of delay increases the risk that today’s encrypted communications will become tomorrow’s exposed secrets. The quantum countdown waits for no one. The time to act is now.