Wookyoung Kim · February 10, 2026
As Rocks May Think
I translated As Rocks May Think, a blog post by Eric Jang, formerly VP of AI at 1X Technology. It shows that AI models are better than we tend to think, and that things once possible only in theory are beginning to become possible in practice.
Whenever logical processes of thought are employed--that is, whenever thought moves along a fixed path--that is a domain where machines can take over. -- Dr. Vannevar Bush, As We May Think, 1945
Think of life as a kind of open-world MMO. A massive update has just dropped on the server. Attention, all players: it is time to change how you play.
Since 2022, the world has changed completely. ChatGPT appeared, and now you can ask AI to find new proofs of Erdos problems. Nation-states are using AI to automate cyberattacks. We live in an era when you can preorder a general-purpose humanoid robot for the home. China's robotics ecosystem is producing more open robots, data, and research results than any other country. Most large tech companies are working on humanoid projects. AI-generated video is indistinguishable from reality. The global economy is being reorganized around scaling up AI models.
The most important change in all of this is that machines are now quite good at coding and thinking.
Like many others, I have spent the past two months immersed in Claude Code, wrestling with the reality that I no longer need to write code by hand. I am currently implementing AlphaGo from the ground up (I plan to open-source the repo soon), both to refresh the fundamentals of deep learning and to learn a new way of programming that uses the full power of modern coding agents. I have set up Claude not only to write infrastructure and research ideas as code, but also to propose hypotheses, draw conclusions, and suggest which experiments to try next.
Actual prompt examples for implementing AlphaGo:
/experiment Apply maximal update parameterization (μP) so we can find optimal hyperparameters during scale-up. Start with GoResNet-100M as the base, and use d-muP for depthwise stability. Train for 1 epoch on the dev-train-100k dataset. Submit at most 4 Ray parallel jobs.
/experiment Study scaling laws. Propose 5 model sizes from 1M to 1B parameters, train each on dev-train-100k in bfloat16, fit the power law L(C) = a*C^b, and generate a Chinchilla-style compute-optimal graph.
/experiment Play the trained neural network checkpoints against gnugo10. Evaluate 20 games total, with a maximum of 81 moves per game. Visualize a policy softmax heatmap for each board state.
Implement MCTS in src/alpha_go/mcts.py according to the notation in the AlphaGo paper. Nodes should include N (visit count), Q (value), and logP (log probability). Add PUCT selection, expansion, and backpropagation, and test it in a toy environment.
Reimplement MCTS in C++ to speed it up. Migrate Go gameplay to cpp as well. Configure Python bindings with Bazel + nanobind, benchmark against the Python implementation, and report the speedup.
Build a distributed replay buffer + data collection workers + trainer architecture. Workers push episodes to the buffer over gRPC, and the trainer pulls i.i.d. samples. Design the buffer to block when the pull/push ratio exceeds 4.0. Use protobuf for serialization.
I think there is a bug in Go scoring. The game result says White wins by 4.5 points, but visually it looks like Black won. Analyze the .npz game file and compare it against the C++ scoring logic in src/alpha_go/cpp/go/go_game.h. Debug the Tromp-Taylor scoring method.
In my 'automated AlphaGo researcher' codebase, I created a Claude command called /experiment to standardize an 'action' in the AlphaGo research environment as follows:
Create an independent experiment folder with a date-time prefix and a descriptive slug.
Write and run the experiment routine as a single Python file.
Save intermediate artifacts and data under data/ and figures/ subdirectories. Store every file in an easy-to-parse format, such as CSV, that can be loaded directly with pandas.
Observe the experiment results, draw conclusions, and summarize what remains unknown and what was newly learned.
The final artifact of the experiment is a report.md Markdown file summarizing the latest observations about the world (example).
* Click /experiment to see how the Claude command is configured.
Here is an example I actually use:
/experiment I want to apply maximal update parameterization to find optimal hyperparameters during scale-up. Use GoResNet-100M as the μP 'base' model. If needed, use the https://github.com/microsoft/mup package, but add it to pyproject.toml so it is installed as a dependency. Also apply d-muP (https://arxiv.org/abs/2310.02244) for depthwise stable transfer. Once MuP parameterization is applied to the model, train for 1 epoch on dev-train-100k to find optimal hyperparameters. You may submit at most 4 Ray parallel jobs at the same time. Evaluate validation loss and accuracy every 500 steps. You may tune the learning-rate schedule, initialization scale, and learning rate. The critical batch size is probably around 32-64. Use 2025-12-26_19-13-resnet-scaling-laws.py as a reference for how to train the model, but delete unnecessary parts. In every run, save intermediate checkpoints every 1k steps to research_reports/checkpoints.
You can also put Claude in charge of experiments that optimize hyperparameters sequentially:
/experiment Run a series of experiments similar to 2025-12-27_22-18-mup-training-run.py, but aim to achieve the best policy validation accuracy within the FLOP budget. Change the following: after each experiment ends, review the results and think about what to try next. Create a new experiment script that reflects those changes. Use a 10M-parameter model as the base model for hyperparameter search. Set BASE_WIDTH=192 and BASE_DEPTH=12. This is the model to tune. DELTA_WIDTH=384, DELTA_DEPTH=12. The FLOP budget per experiment is 1e15 FLOPs. Each time results come in, review them together with previous experiments and make a reasonable judgment about what to try next. Run 10 of these sequential experiments and write a report summarizing what was learned.
Previous generations of 'autotuning' systems, such as Google's Vizier, ran Gaussian process bandits over user-defined hyperparameter spaces. Modern coding agents, however, can change the code itself. Their search space is not only unconstrained; they can also reflect on whether experiment results are consistent, develop theories to explain the results, and test predictions based on those theories. Overnight, the combination of coding agents and computer-tool use has evolved into an automated scientist.
* Gaussian process bandit: a Bayesian optimization technique that models the posterior distribution of an objective function with a Gaussian process, then automatically balances exploration and exploitation to find the optimum.
Software engineering is only the beginning. The real shock is that we now have general-purpose thinking machines that can use computers and solve almost any short digital problem. Want to run a series of research experiments to improve a model architecture? No problem. Want to implement an entire web browser from scratch? It will take some time, but it is possible. Want to prove an unsolved math problem? It will do it without asking to be listed as a coauthor. Want to tell an AI agent to optimize its own CUDA kernels so it upgrades itself to run faster? A little scary, but it works.
Excellent debugging and problem-solving ability is a byproduct of reasoning, and that ability in turn becomes the power to pursue a goal persistently. This is why coding REPL agents have spread so quickly: they are relentless toward a goal, and they explore well.
We are entering a golden age in which every computer science problem appears solvable, in the sense that we can obtain highly useful approximations to any computable function. I would not go so far as to say that 'computational complexity can now be ignored,' but looking back over the past decade, Go, protein folding, music and video generation, and automated theorem proving were all once considered computationally impossible, and now they are within reach even with a PhD student's compute resources. AI startups are using LLMs, armed only with a few verifiers and hundreds of megawatts of compute, to discover new laws of physics and investment strategies. The introduction to this paper by Scott Aaronson is worth reading, and it becomes even more meaningful if you keep in mind that several labs today are seriously exploring proofs of the Millennium Prize Problems.
* Scott Aaronson's paper, discussed in 2017 only as a theoretical possibility, is now becoming reality. Section 1.1 For if someone discovered that P = NP, and if moreover the algorithm was efficient in practice, that person could solve not merely one Millennium Problem but all seven of them--for she'd simply need to program her computer to search for formal proofs of the other six conjectures. In other words, if someone discovered that P = NP and the algorithm was efficient in practice, that person could solve not just one Millennium Problem but all seven, because they would only need to have a computer search for formal proofs of the remaining six conjectures. Section 1.2.3 For example, presumably no one would try using brute-force search to look for a formal proof of the Riemann Hypothesis one billion lines long or shorter, or a 10-megabyte program that reproduced most of the content of Wikipedia within a reasonable time (possibly needing to encode many of the principles of human intelligence in order to do so). Yet both of these are 'merely' NP search problems, and things one could seriously contemplate in a world where P = NP. For example, probably no one would try to brute-force search for a formal proof of the Riemann Hypothesis of one billion lines or fewer, or for a 10-megabyte program that could reproduce most of Wikipedia within a reasonable time (such a program would likely need to encode many of the core principles of human intelligence). But these are 'merely' NP search problems, and they are things one could seriously consider in a world where P = NP.
I am exaggerating deliberately for a reason. Do not look only at AI capabilities at this exact moment; think about the rate of progress and imagine what the capabilities will be 24 months from now. It is easy to point to the places where AI models still fail and dismiss the whole thing as 'AI zealot nonsense.' But meanwhile, rocks have begun to think.
Coding assistants will soon become good enough to effortlessly spin up any digital system. It will be like having a $20-a-month wish-granting genie. Soon, an engineer will be able to point their AI at any SaaS website and say, 'Rebuild that. Bring up the frontend, backend, API endpoints, and services. The whole thing.'
What Is Reasoning?
To predict where thinking and reasoning abilities are headed, it is important to understand the line of thought that led to today's reasoning LLMs.
Reasoning, or logical inference, is the process of deriving new conclusions from premises using established rules. It can be divided broadly into two kinds: deductive reasoning and inductive reasoning. Deductive reasoning draws true conclusions by applying valid logic to true premises. Combining 'all mammals have kidneys' with 'all horses are mammals' to conclude 'all horses have kidneys' is one example. In tic-tac-toe, if you enumerate every possible future game and every opponent move, you can deductively determine whether you can win.
Before LLMs, symbolic reasoning systems such as Cyc tried to build databases of commonsense knowledge. If you entered basic 'facts about reality that everyone agrees on,' a deductive search process would add new connections to the graph. But this approach did not work. The real world is messy, and nothing is truly certain. The horse mentioned above might be missing a kidney and still be a mammal. If even one premise is wrong, the entire chain of logic collapses.
You might think deductive reasoning would be useful in 'logically pure' domains such as mathematics or games, but deduction alone does not scale. The reason we can deduce optimal moves in tic-tac-toe is that there are only 255,168 unique games. In board games such as chess or Go, the number of possible games is far too large for exhaustive search.
Inductive reasoning, by contrast, makes probabilistic statements. Bayes' rule, P(A|B) = P(B|A)P(A)/P(B), is the most widely used technique for 'computing new statements.' For example: P('X is male'|'X is bald') = P('X is bald'|'X is male') × P('X is male') / P('X is bald') = 0.42 × 0.5 / 0.25 = 0.84.
You could imagine building a knowledge graph containing conditional probabilities P(A|B) and P(A|¬B) for every statement A and B, then repeatedly applying Bayes' rule to reason about new pairs X and Y. But exact inference in such Bayesian networks is NP-hard. You have to consider every possible value of every intermediate variable in the chain between X and Y, which is similar to being unable to exhaustively search the exponentially many game states in Go. Here too, pure deductive logic kneels before computational cost, and we ultimately have to rely on clever factorization or sampling.
Even if efficient inference algorithms exist, the practical problem with Bayesian networks is that small probabilities keep getting multiplied, causing beliefs about everything to spread out into vague, low probabilities. With each reasoning step, everything becomes more tangled. Take a self-driving car: if perception, scene graphs, path-planning outputs, and control outputs are all tied together as random variables in one large probabilistic belief network, uncertainty accumulates up the stack and produces an overly conservative decision-making system. Humans, by contrast, do not seem to compute and multiply the likelihood of each component one by one; we appear to handle uncertainty more holistically. This is exactly why modeling end-to-end probabilities with neural networks is so computationally powerful. A neural network approximates all variable elimination in a single forward pass.
* Forward propagation: the process in which input data flows through a neural network from the input layer to hidden layers to the output layer, producing a prediction.
* To compute P(Y|X) in a Bayesian network, every possible value of every intermediate variable Z1, Z2, ..., Zn between X and Y must be summed over and eliminated. A neural network, however, does not perform this process explicitly. It approximates it with a single input and output.
AlphaGo
AlphaGo was one of the first systems to combine deductive search with deep-learning-based inductive reasoning well enough to solve a problem. The deductive step is simple: what moves are legal? What happens to the board when you place a stone? The inductive step is also simple: use a policy network to explore the most promising parts of the game tree, and use a value network to look at the board 'intuitively' at a glance and predict the win probability. The policy network prunes the width of the tree during expansion, and the value network prunes its depth.