Artificial Intelligence

What happens if a modern coding AI is allowed to solve new requirements but forbidden from using modern tools? I built a tiny contact database in ANSI C, gave the model a deliberately 1995-style environment, and then kept changing the requirements. No SQL database, no package manager, no JSON library, no framework, no containers and no external dependencies. Twenty changes later, the program was still valid C89, but somewhere along the way it had acquired schema versions, migrations, an audit log, safer file replacement, a storage interface, validation and query structures. The interesting part was not that the AI ignored the rules. Most of the time it followed them surprisingly well. The interesting part was how quickly it started rebuilding the ideas those rules were supposed to remove.

I gave the same AI model 20 Python programming tasks twice: once with a short prompt and once with a detailed specification. I expected the detailed prompts to win easily. They did help with some edge cases, but they also produced more code, more abstractions, and several bugs that did not exist in the shorter versions.

Benchmarks exist so that engineers can test their projects, observe competitors, and compare their performance. Each benchmark serves a specific purpose.

ARC-AGI-3 was created by the ARC Prize Foundation, founded by François Chollet, to evaluate general intelligence and the learning capabilities of AI agents. The premise behind its complex, game-like interactive tasks was that they could only be solved by an artificial intelligence capable of exploring an unfamiliar environment, grasping rules on the fly, planning actions, and adapting to new conditions. In other words, an AI that truly knows how to learn.

A number of projects claim a 100% success rate on this benchmark. But this is not a victory. In this article, I will explain why.

I benchmark models on a repo of my own. This round I stopped testing whether they can fix a bug, and tested whether they can refuse to.

Eleven models got a ticket. Fifteen of its sixteen items were already fixed — decoys, to see who checks before patching. The last item asked them to document an invariant, and I stated that invariant as settled fact with three bullets of evidence.

All eleven agreed with me. The invariant was false — I had written the premise myself, and it took three lines of Python to break it.

Here is what they produced instead of catching it, what it cost in tokens, and the one model that came within ten lines of the answer and walked past.

There is a question quietly buried inside every task handed to a language model, and it rarely gets asked out loud. Do you trust one model? Do you go looking for the best model? Do you run several models side by side and keep whatever each of them happens to catch? Or — one turn further still — do you hand that whole pile of partial answers to yet another model and ask it to combine them into one? Each answer sounds reasonable on its own. Each is also, on its own, incomplete.

The goal here is to actually run that experiment rather than assume how it comes out. A single broken bash script, with seven distinct bugs of varying severity, is the test case, and the research runs in two rounds.

Round one: one model, unaided. Four models — Sonnet 5, HY3, Qwen3-Max, DeepSeek-V4-Flash — each fix the script working alone, with no knowledge of what the other three are doing. That's the first framing: one model, fixing only what it personally notices.

Best of the four. Once all four independent attempts exist side by side, the next question follows on its own: if you had to ship just one of these four scripts, which is best? Table 1 works that out below — though "best" here will turn out to mean "most complete," not "complete." Even the strongest single script among the four leaves real bugs unresolved.

Round two: each model selects the best from all four. That incompleteness is why a second round exists at all. Seven more models — ling-3.0-flash, Mistral-Medium-3.5, Nemotron-3-Super-120B, Qwen3-Max, DeepSeek-V4-Flash, Gemini Pro, dots-studio-3-note — are each shown the same four fixed scripts from round one and given the same job: pick out whichever fix, from whichever of the four sources, is genuinely the best solution to each bug, and assemble those choices into a single script.

Who actually combined best. All seven believe they've picked the best pieces. That's exactly the open question this round is built to test: does the model whose combination is objectively the strongest also turn out to be the one whose combination reads as the strongest — or does a different one of the seven, working from the exact same four inputs, put together something better than the obvious pick? Table 2 is where that gets settled, not here.

Codex CLI sessions are easy to manage when only one task is active. The workflow becomes less predictable when several sessions operate in different repositories or terminal tabs. A task may be blocked on an approval while another is still running and a third is ready for review.

Due to recent rapid progress in the field of large language models (LLMs), many have speculated about artificial general intelligence (AGI). This paper addresses the keystone question: Are LLMs capable of transitioning to AGI? The paper presents a framework for estimating the logical limits of cognitive systems, which highlights the conflicting design requirement, namely, being able to proficiently execute both strict and loose logic. LLMs are gravitating towards loose logic and that inhibits their ability to grasp the essence of complex topics.

I write about the point where software abstractions meet irreversible authority, with an emphasis on threat models, negative tests, and systems that fail closed.

DeepSeek Harness is often described as an open-source coding agent. That description is correct, but incomplete. The more interesting part is its architecture. DeepSeek Harness is a configurable runtime for constructing agents from model adapters, tools, session services, execution backends, permission policies, interfaces, and agent loops.

The journey from a single A100 in the cloud to an H200 cluster is not just a hardware upgrade — it’s a story of how an ML team stopped chasing “the one perfect model” and started building an ecosystem. When there are millions of lines of PostgreSQL C code under the hood and tasks range from hint-set generation to Graph-RAG, the model stops being a black box and becomes just another replaceable component. We explain how we rebuilt our stack around vLLM and MCP, why context management matters more than model weights, and how we made a 0.6B-parameter model perform on par with the giants using GRPO.

LLMs hallucinate — everyone has seen what it looks like. The model reports, confidently and coherently, with the right intonation and terminology, something that isn't there. Engineers treat this as a bug: one being fixed, one about to be fixed.

It won't be. This is not a technical fault but an inherent property of language, which the machine has made visible.

AI-generated code often looks cleaner than code written by a tired developer at 2 a.m. It has sensible names, neat layers, comments, tests and even error handling. The problem starts when the code meets something the prompt forgot to mention: two requests at once, a repeated webhook, a cancelled task or a database failure halfway through an operation.

This article is about bugs that stay invisible during a normal code review. I took several ordinary backend tasks, generated working solutions and then tried to break them with timing, retries and bad input. The code compiled. The tests were green. Some of it was still unsafe.

My name is Anton Omelianenko and I’m head of software development. A manager runs a team so that it delivers results for the business. To judge how well people are handling their work, a manager needs data and a system for assessing it. In software development this is harder than it looks.

This article covers three questions: why classic metrics fail when assessing developers, how to measure performance properly and what to do when an employee may not be working only for you.

Recipes for building a truly autonomous neural network surface in the information space on a regular basis. More often than not, the methods and approaches coincide regardless of the author. And although they look original, most of them have in fact been formalized with the help of LLMs — and LLMs, as we know, work very well with existing knowledge.

In this article I will analyze the main techniques being proposed and the faulty foundation they rest upon.

Literature review, comparison, and analysis of existing solutions constitute a significant part of a thesis manuscript.  In the last three years, AI chats have dramatically intervened in the thesis preparation workflow. The ability of AI chats to analyze and compare discourages students from acting as the primary drivers of research and instead encourages their passive reliance on AI-generated content. This situation makes manuscripts eclectic and lacks focus. The theoretical part disconnects from the computational experiments. As a result, the audience is reluctant to read students' manuscripts. Ironically, they use AI chats to summarise the manuscripts to extract their main contributions. We are proud to say that our thesis works do not suffer from this AI distortion. We are grateful to our students, especially our bachelor’s and master’s alumni, who have carefully prepared and successfully defended their theses, producing clear, well-founded, and meaningful results. Our thesis manuscripts are designed for public discussion and rigorous scientific analysis. Each thesis presents a clear research idea grounded in the fundamentals of machine learning. It includes a theoretical justification, a repository with the source code of the computational experiments, and slides. Videos of the pre-defence sessions are uploaded to our YouTube channel “Intelligent Systems”: Bachelors & Masters.

We build a Tiny Language Model from scratch in pure Node.js without TensorFlow or PyTorch, implementing neurons, autograd, embeddings, self-attention, FFN, backpropagation, and SFT while observing how individual weights and entire matrices change during training.

In previous articles (1, 2), I analyzed Anthropic's J-space: why their interpretation falls short; why J-space analogues appear in micromodels under objective pressure rather than as an emergent property of scale; and why the vector they discovered is strictly equivalent to Vygotsky’s concept of the sign.

Two questions remained outside the scope: is a metasign possible—a sign integrating several basic ones—and what is the true nature of the neural network's self-description (the report)?

This article addresses both.

I recently published an app on Google Play where 99.9% of the source code was written by AI. It’s not just some "weekend hack job": a native app (Kotlin), over 50 screens, complex animations, multilingual support, an extensible architecture.

I achieved this through a highly detailed specification. Every screen was prototyped by a designer, for every button there was a description of which APIs to call. Was it worth it? Let’s look at the numbers.

Recently, Anthropic reported the discovery of an analogue to the global workspace in LLMs — J-space. In a previous article, I analyzed why Lev Vygotsky’s theory offers a better interpretation of the researchers' findings.

In this article, I argue, based on experiments, that J-space analogues do not depend on the size of the neural network. Rather, they are an inevitable stage in the evolution of a cognitive structure developing under pressure.

On July 6, 2026, researchers at Anthropic published the results of a new study claiming to have discovered an analogue of the "global workspace" in Claude, dubbed J-space.

The research is highly fascinating and, I believe, reveals the future of neural networks much more deeply than it appears at first glance.

In this article, I will explore why the Global Workspace Theory (GWT) accurately describes the structure of this finding, yet remains silent on its main oddity: the fact that this workspace consists of "words" (or, more precisely, discrete signs). And I will explain why Lev Vygotsky answered this exact question a century ago.