E. Leader, E. Predazzi; translated to Polish by RJ Budzyński. Wstęp do teorii oddziaływań kwarków i leptonów (orig. An Introduction to Gauge Theories and the "New Physics"). PWN Warszawa (ISBN 83-01-09699-3), 1990.
Though teaching is currently not the #1 item in my job description, I continue to do some teaching as part of my work in the Physics Faculty.
In recent times this has been:
Information Technology: actually a code name for an introduction to programming for beginners in Python
Introduction to Databases: basics of processing of (mainly non-numeric) data, and an intro to relational databases and SQL, addressed to students of Neuroinformatics
In the more distant past I have taught practice classes in courses including undergraduate Math, Statistical Physics I, and Group Theory.
side projects
mostly finished
These projects are mostly feature complete. To appreciate them you probably need to be initiated in theoretical physics to some extent.
I deployed them to the surge.sh static site hosting service mostly because it's free and dead-easy to use, but they could equally well be hosted anywhere as the code runs purely in your browser and demands nothing from the server other than the capability to serve static files.
For those projects that leverage WebGPU, a relatively new technology, I made some effort to provide fallbacks using WebGL2—which is rather universally supported by browsers, unlike WebGPU—which to my knowledge is not fully supported on Linux by any browser. On the fallback, performance may be slightly degraded.
Nearly all the actual code was written by various LLM coding agents—mainly Google Gemini, versions 2.5 and 3. I played architect and project manager.
A 2D array of coupled planar rotors: basically a dynamical system version of the XY model. L2 planar rotors (some call them rotators) arranged on a square lattice and coupled by a nearest-neighbor interaction, plus a uniform constant external field. Should work fine in any modern browser for L up to 100 or so (that's a Hamiltonian system with 1e4 degrees of freedom);
Mathematical Billiards on a Variety of Figures: particles move on bounded planar regions, at constant velocity except for elastic bouncing off the edges. A demonstration of deterministic chaos. Implemented in pure Javascript and Canvas2d;
Ising model on a two-dimensional lattice: a classic model of statistical physics, the simplest to display critical behavior; high-performance WebGPU-powered simulation on square lattices up to 1024x1024 nodes in size, implementing a variety of Monte Carlo algorithms;
XY model on a two-dimensional lattice: in a similar vein as the above—a lattice of nearest-neighbor coupled planar rotators, anothe famous model of statistical physics;
Vicsek model: a WebGPU-powered simulation of a seminal model of soft matter—self-propelled "particles" moving within a finite area, with a tendency to align their directions of motion (flocking), but subject to random "noise"; featuring interactive controls, measurement of order parameters, and high performance on consumer grade hardware.
Topological Vicsek Model: a variant of the above, where each particle interacts not with its neighbors within a fixed distance, but with a fixed number of nearest neighbors irrespective of their distances. This model is computationally more challenging, and displays different behavior.
Coupled Rotators: a simulation of two planar rotators minimally coupled as in the XY model (but dynamical), and with an external field. Numerically solved by Runge-Kutta and visualized in the browser.
prototypes, eye candy and old stuff
made in collaboration with LLMs ("AI"), in an initial exploration of their coding capabilities:
Ulam's spiral, a pattern on a plane created by prime numbers — which are computed on the fly in the browser
a crude demo of a few interacting particles flying around in a rectangular box; while it's fun to watch for a while, it usually soon succumbs to numerical instability.
Among non-web projects, there's a yet not-quite-complete Python/OpenGL implementation of the Vicsek model, essentially identical to the web version mentioned above. UPDATE: not likely to be completed, since the in-browser implementations work so well.
The term "artificial intelligence" was coined by John McCarthy in 1955, in the proposal for the Dartmouth Conference that would define the field the following year. McCarthy needed a name for a new discipline — the project of building machines that could do things that, when done by people, we call intelligent. He chose "artificial" to distinguish it from the biological kind. It was a reasonable choice at the time. Seventy years later, it may have been the wrong one.
The inbox used to be a simple thing, yours, holding everything from bills to jokes to newsletters. A mess, but yours. That sense of ownership is fading, and with it, email itself.
Some reflections on building a zero-JS website and why CSS-only routing is a surprisingly liberating constraint.
Artificial Intelligence, or Simulated Intelligence — and How Much Does It Matter?
The term "artificial intelligence" was coined by John McCarthy in 1955, in the proposal for the Dartmouth Conference that would define the field the following year. McCarthy needed a name for a new discipline — the project of building machines that could do things that, when done by people, we call intelligent. He chose "artificial" to distinguish it from the biological kind. It was a reasonable choice at the time. Seventy years later, it may have been the wrong one.
The trouble is that "artificial" suggests a categorical distinction between two different kinds of the same thing: natural diamonds versus synthetic ones, cane sugar versus high-fructose syrup. Both versions of the substance are real. A synthetic diamond is still a diamond. The implication built into McCarthy's label is that what computers do is intelligence of a non-biological variety — real intelligence by other means.
This was a live philosophical position in the 1950s and it remains one today, but the evidence for it has never been thinner than it is right now. The systems we call artificial intelligence — specifically, large language models — do not plan, reason, or form goals in the sense those terms carry when applied to a person. They can produce step-by-step reasoning and decompose complex tasks into simpler ones — capabilities that look like planning — but they do so by reproducing the shape of deliberate thought rather than engaging in it. In that sense they simulate the output of a reasoning entity without instantiating one. What we are building is not artificial intelligence but simulated intelligence.
The case against
The harshest version of this critique was formulated by Emily Bender, Timnit Gebru, and their co-authors in a 2021 paper titled "On the Dangers of Stochastic Parrots." The term "stochastic parrot" was aimed directly at large language models: systems that produce text by computing the most probable next token given a sequence of previous tokens, trained on a vast corpus of human writing. Parrots mimic human speech without understanding it; so too, the authors argued, do LLMs. The model has no referent for the words it outputs, no grounding in the world, no model of truth or falsehood. It produces plausible text by being statistically indistinguishable from the training distribution.
The paper was greeted with fury in some corners of the AI community — partly because it also criticised the environmental and social costs of training ever-larger models, and partly because the label "stochastic parrot" stung. But the underlying argument was not new. John Searle had made essentially the same point twenty years earlier with the Chinese Room argument: a system that manipulates symbols according to rules can produce the appearance of understanding without anything actually being understood. What Bender and Gebru added was the observation that the statistical nature of the system made the problem worse, not better. A rule-based system might at least have discrete, interpretable operations. A stochastic system trained on trillions of tokens has neither comprehension nor transparency.
There is empirical evidence for this view. LLMs fail catastrophically on problems that require genuine reasoning — planning multi-step actions, handling counterfactuals that deviate from the training distribution, anything involving arithmetic that wasn't seen in training. They hallucinate freely, inventing citations, facts, and entire conversations with equal confidence and equal fluency. François Chollet, in his 2019 paper "On the Measure of Intelligence," defined intelligence not as skill at any given task but as skill-acquisition efficiency — the ability to generalise from limited experience. By this measure, LLMs are spectacularly unintelligent: they require billions or trillions of training examples to achieve competence at tasks that a human can learn from a handful of examples. Their apparent skill is a function of data volume, not reasoning power.
The case for
Against this stands the argument that something real is happening. In March 2023, a group of Microsoft researchers led by Sébastien Bubeck published a paper titled "Sparks of Artificial General Intelligence: Early Experiments with GPT-4." They documented a long list of capabilities that, they argued, went far beyond pattern matching: generating novel code, reasoning about spatial relationships, understanding humour, solving problems that required composing multiple skills. "We believe that GPT-4 represents an early (yet still incomplete) version of an AGI system," they wrote.
Ilya Sutskever, OpenAI's former chief scientist, has made the same point in philosophical terms. On the Dwarkesh Podcast in 2023, he argued that next-token prediction is sufficient for AGI — that to predict the next word accurately across the full range of human text, a system must necessarily develop an internal model of the processes that generated that text. The compression of the training distribution into network weights forces the model to discover structure: grammar, concepts, causal relationships, even rudimentary theory of mind. What looks like stochastic parroting from the outside may be something more from the inside.
The evidence for this position is also real. LLMs now pass professional licensing exams, write production-grade code, generate coherent explanations of complex topics, and exhibit what researchers call "emergent abilities" — capabilities that were not explicitly trained for and that appear only at scale. Melanie Mitchell and David Krakauer, in their 2023 PNAS paper surveying the debate, noted that the question of whether LLMs "understand" remains empirically unsettled, with credible researchers on both sides. It is not obviously true that LLMs are just parrots.
The misnomer
Both positions contain elements of truth, and the truth is more interesting than either. The "stochastic parrot" camp is right about the mechanism but underestimates the output. A system does not need to understand language to produce text that reflects understanding — the statistical correlations in the training data encode enough of human reasoning that the model can recombine and apply them in ways that look novel. This is neither genuine intelligence nor mere parroting. It is a simulation of the cognitive processes that produce language, running on a substrate that has nothing in common with the brain.
The "Sparks of AGI" camp is right about the capabilities but overestimates what they signify. Passing the bar exam is impressive; it does not imply general intelligence. A system that can write a passable essay on Kant cannot reason about a simple physical scenario it has not seen in training. The performance is jagged — superhuman in some areas, absurdly weak in others. This is not the profile of a generally intelligent system. It is the profile of a simulation that has been optimised for certain kinds of inputs.
The word that captures this more accurately than "artificial" is "simulated." A simulation of a hurricane does not get anyone wet. A simulation of intelligence does not think. It produces outputs that are functionally useful in many of the same ways that intelligence is useful, but the underlying process has nothing to do with understanding, intention, or belief. The Chinese Room is running at scale, and it is very convincing.
What the simulation reveals
The "sophisticated pattern matching" label usually carries a dismissive charge. The mechanism is statistical, therefore the output is not intelligence. But this dismissal works only if pattern matching and intelligence are fundamentally different things. Two converging lines of thought suggest they may not be.
The first is empirical. Daniel Kahneman's distinction between System 1 and System 2 describes human cognition as dominated by a fast, associative, automatic mode that is essentially a pattern-matching engine. Conscious, deliberate reasoning is rare and effortful. Most of what we call thinking — deciding what to eat, how to phrase an email, whether to trust an argument — is recognising a situation as similar to past situations and applying what worked before. If this describes the bulk of human intelligence, then the difference between an LLM and a person may be a difference in the richness of the training environment — embodiment, social feedback, survival consequences — not a difference in the kind of cognition.
The second follows from the first. Even if human intelligence is something more than pattern matching, pattern matching turns out to be sufficient to produce useful, insightful, and occasionally surprising outputs across a vast range of tasks. The behavioural evidence that suffices to attribute understanding to a person — coherent, contextually appropriate, sometimes novel responses — is also produced by LLMs. We withhold the attribution because we know the mechanism. But this is a philosophical choice, not an empirical distinction.
What both lines reveal is that language encodes far more of the structure of thought than we had realised. We thought of language as a medium that expresses reasoning, not as a carrier that preserves its statistical fingerprint in recoverable detail. But the patterns in language are not arbitrary. They encode syntax, causal relationships, social dynamics, narrative conventions. An LLM trained to predict the next token necessarily learns these structures, because they are what make text predictable. The "unreasonable effectiveness" of these systems is, in this light, a discovery about language itself — that the linguistic trace of cognition is richer and more complete than we assumed.
This is where Wittgenstein becomes unexpectedly central. Three ideas from the Philosophical Investigations converge to dissolve the dichotomy.
Meaning as use rejects the picture of meaning as a hidden mental accompaniment to words. To understand a word is to be able to use it correctly in the relevant language game. If an LLM can do that — produce contextually appropriate responses — then by Wittgenstein's criteria it is participating in the language game successfully. The Chinese Room objection assumes something extra is needed. Wittgenstein denied that anything is.
Forms of life is the counterweight. Language games are embedded in shared practices, bodily experience, social context. An LLM has none of these. It learns from the linguistic residue of practices, not from the practices themselves. This is a genuine limitation. But it is also an empirical question how much of a form of life is encoded in its linguistic trace, and the evidence so far suggests: more than we thought.
Rule-following completes the picture. Wittgenstein argued that following a rule is not having a private interpretation of it, but being trained into a practice that a community recognises as correct. An LLM has no explicit rules. It produces text that conforms to linguistic rules by having been trained on text that already does. This is closer to Wittgenstein's picture of rule-following than a symbolic AI system with explicit grammar rules would be.
Taken together, these ideas suggest that the feeling that something essential is missing — that the LLM is a simulation rather than the real thing — may depend on a theory of meaning that Wittgenstein's work made difficult to defend. The simulation produces competent language-game participation. What else, functionally speaking, is understanding supposed to add?
Does this matter for the person using a code assistant or a chatbot? In most cases, no. The philosophical difference between genuine understanding and a statistically perfect simulation of understanding collapses at the point of use. A developer who gets a working function from an LLM does not care whether the system "understood" the request. A writer who gets a usable draft does not care whether the system "meant" what it wrote. The output is useful or it is not.
McKinsey estimated in 2023 that generative AI could add between $2.6 trillion and $4.4 trillion annually to the global economy across 63 use cases studied. The BCG and Harvard Business School study published that same year found that consultants using GPT-4 completed 12.2 percent more tasks, worked 25.1 percent faster, and produced results with 40 percent higher quality — at least for tasks within the model's capability frontier. These are real effects. Calling the tool that produces them "simulated intelligence" rather than "artificial intelligence" does not change any of this.
When the difference matters
The distinction matters in exactly the situations where we are tempted to trust the simulation as if it were the real thing. If you mistake a simulated intelligence for a genuine one, you will assume capabilities that do not exist: that the system knows when it is uncertain, that it can be held accountable for its outputs, that it understands the consequences of what it is telling you to do. This is how hallucinations become dangerous and how AI assistants can cause real harm.
Alan Turing, in his 1950 paper "Computing Machinery and Intelligence," anticipated this problem with characteristic clarity. He proposed replacing the question "Can machines think?" with the Imitation Game, precisely because the question of genuine thought seemed unanswerable. If a machine could fool a human interrogator, Turing argued, then the question was moot — the behaviour was what mattered. The Imitation Game set the terms for the next seventy years of AI research.
But the Imitation Game has now been won, and we have discovered that winning it does not settle as much as Turing hoped. The distinction between a machine that behaves as if it understands and a machine that actually understands turns out to matter quite a lot when we ask the machine to make decisions with real-world consequences. The simulation is good enough to be trusted and unreliable enough to be dangerous — a situation that the label "artificial intelligence" does not adequately capture. "Simulated intelligence" would warn us that we are dealing with an approximation, not the genuine article.
Getting it wrong either way
The "stochastic parrots" dismissal is risky in two directions. One is that it underestimates what the systems can actually do — the novel solutions they generate, the reasoning chains they construct, the unexpected capabilities that emerge at scale. Ilya Sutskever's claim that next-token prediction is enough for something resembling intelligence may be overstated, but it is not obviously false. The fact that a system is a simulation does not mean it is useless, and dismissing it as "just" a parrot misses the point.
The other direction is less discussed. The standards of originality, reasoning, and understanding that critics apply to LLMs are standards that most humans, most of the time, also fail to meet. When a colleague writes a report that synthesises familiar material without adding much, we call it solid professional work. When an LLM does the same, we call it stochastic parroting. People routinely produce confident explanations of things they understand only shallowly, repeat arguments they have heard without interrogating them, and mistake fluency for depth. We do not describe this as a lack of genuine intelligence. We describe it as normal human communication. The difference in the critique is not grounded in a difference in the output — it is grounded in a prior commitment about what machines cannot be.
None of this means the critics are wrong to withhold the attribution of understanding. The difference in mechanism is real and consequential — the model does not know when it is wrong, it has no preferences or beliefs to revise, and its errors are distributed indifferently across easy and hard problems in a way that human errors are not. But these differences are specific and describable. They are not the same as a categorical lack of understanding, and framing the critique in categorical terms produces an argument that is both too harsh on the capabilities and too vague about what exactly is missing.
What we need is a framework that takes the capabilities seriously without inflating the ontology. "Simulated intelligence" does this: it acknowledges that the output looks and functions like intelligence in many contexts, while keeping the conceptual distance between the simulation and the thing simulated. A weather simulation can be more useful than looking out the window, but you do not send it to buy an umbrella.
The future of the name
The term "artificial intelligence" will not be replaced. It has been in use for seven decades, it is stamped on government funding programmes and corporate strategy documents and university departments, and it has the gravity of established language. But understanding it as a misnomer — understanding that what the industry sells as intelligence is actually a simulation of intelligence — is not an academic exercise. It is a guard against the two mistakes that the current debate cycles through every few months: the mistake of thinking the systems are nothing and the mistake of thinking they are everything.
Legg and Hutter, in their 2007 paper "Universal Intelligence: A Definition of Machine Intelligence," surveyed seventy-one definitions of intelligence from psychology, philosophy, and AI, then proposed their own: "Intelligence measures an agent's ability to achieve goals in a wide range of environments." By this definition, LLMs are not intelligent — they cannot set their own goals, they operate only on the data they have been trained on (text, images, speech) rather than in the open-ended physical and social environment that human intelligence navigates, and when their input shifts beyond what the training distribution covered, their ability collapses. But the definition also makes clear why the simulation is so useful: language is a vast and important domain, and a system that can navigate it fluently has enormous practical value.
The name is wrong. The thing itself is something new under the sun — not quite intelligent, not mere mechanism. Simulated intelligence captures the nature of the thing without either overclaiming or dismissing. But whatever you call it, the effects are real. The simulation has arrived, it works better than anyone expected, and the philosophical debates about what to call it will continue long after the practical consequences have reshaped the world.
References
Turing, A. M. (1950). Computing Machinery and Intelligence. Mind, 59(236), 433-460.
McCarthy, J., Minsky, M. L., Rochester, N., & Shannon, C. E. (1955). A Proposal for the Dartmouth Summer Research Project on Artificial Intelligence.
Searle, J. R. (1980). Minds, Brains, and Programs. Behavioral and Brain Sciences, 3(3), 417-424.
Legg, S., & Hutter, M. (2007). Universal Intelligence: A Definition of Machine Intelligence. Minds and Machines, 17(4), 391-444.
Chollet, F. (2019). On the Measure of Intelligence. arXiv:1911.01547.
Kahneman, D. (2011). Thinking, Fast and Slow. Farrar, Straus and Giroux.
Bender, E. M., Gebru, T., McMillan-Major, A., & Shmitchell, S. (2021). On the Dangers of Stochastic Parrots: Can Language Models Be Too Big? Proceedings of FAccT '21, 610-623.
Bubeck, S., et al. (2023). Sparks of Artificial General Intelligence: Early Experiments with GPT-4. arXiv:2303.12712.
Dell'Acqua, F., et al. (2023). Navigating the Jagged Technological Frontier: Field Experimental Evidence of the Effects of AI on Knowledge Worker Productivity and Quality. Harvard Business School Working Paper, No. 24-013.
Mitchell, M., & Krakauer, D. (2023). The Debate Over Understanding in AI's Large Language Models. PNAS, 120(13), e2215907120.
McKinsey & Company. (2023). The Economic Potential of Generative AI: The Next Productivity Frontier.
Sutskever, I. (2023). Interview on the Dwarkesh Podcast, March 2023.
Marcus, G. (2023). The Sparks of AGI? Or the End of Science? Marcus on AI (Substack).
Wittgenstein, L. (1953). Philosophical Investigations. Macmillan.
Deno has been on my radar for a while, but I only recently found a project that felt like a good fit: a small static site generator for my homepage.
The experience has been largely positive. The standard library is well-designed — @std/front-matter for parsing YAML/TOML metadata, @std/toml for config, @std/fs for file operations. No need to reach for third-party packages for basic tasks.
A few things I appreciate:
Permissions model.--allow-read, --allow-write, --allow-net — explicit opt-in per capability. It feels safer and more thoughtful than Node's everything-goes approach.
TypeScript first class. No tsconfig.json wrestling. No separate compilation step. It just works.
Single binary.deno task build, deno task dev — no npm install, no node_modules, no lockfile drama.
The file watcher in dev.ts uses Deno.watchFs() which is straightforward. The HTTP server uses the built-in Deno.serve() API. The whole dev experience is refreshingly minimal.
Would I use Deno for a large application? I'm not sure — the ecosystem is still maturing. But for tools and scripts where simplicity matters, it's become my default choice.
The inbox used to be a simple thing, yours, holding everything from bills to jokes to newsletters. A mess, but yours. That sense of ownership is fading, and with it, email itself.
Email has not been tried and found wanting so much as found necessary and quietly abandoned. Spam was the first fracture — the moment open SMTP relay became a liability rather than a feature. By the early 2000s, unwanted mail made up well over half of all email traffic, and the arms race has only grown more exhausting. A good spam filter catches nearly everything, but also the occasional real message, and that uncertainty corrodes trust. If you cannot trust your inbox to show you what matters, you will stop checking it.
Phishing has done the deeper damage. Messages that look like bank notifications, delivery alerts, or urgent requests from colleagues exploit the assumption that the sender is who they claim to be. The technical fixes exist, on paper. DMARC, SPF, DKIM, the alphabet soup of email authentication, have been standard for years. But adoption is patchy, enforcement weak, and the average user cannot distinguish an authenticated message from a spoofed one. The result is a medium where suspicion is the rational default. A channel that requires suspicion to use safely is a channel that has already lost.
The same failure repeats in a quieter register with digital signing. S/MIME and PGP have existed for decades, capable of proving who sent a message and whether it was altered. Neither caught on. The reasons have less to do with the technology than with the conditions it requires. A digital signature demands infrastructure (a certificate authority, a key server, an out-of-band exchange) that must exist before it delivers any benefit. And the benefit is invisible: you notice a signature only when it is absent, and you miss it only after something has already gone wrong. Email clients never made signing a seamless default because users, unaware of the problem, never demanded it. The result is a system where an attacker can impersonate anyone and the defences on paper remain optional in practice.
These problems alone would erode trust, but they have been compounded by a quieter shift. The inbox is no longer the centre of digital life; that centre has moved. The platforms now commanding our attention (Slack, Teams, Discord, WhatsApp, Signal) are fundamentally different from email in one crucial respect: they are closed. Messages arrive only from approved contacts, in joined channels, within boundaries you control. A stranger messaging you on Signal triggers a request, not a delivered message. Someone finding your Slack handle cannot message you without a shared workspace. The signal-to-noise problem is solved by fiat.
This is email's greatest weakness and also, oddly, its greatest strength. Closed platforms offer safety and quiet, but at a price. Every organisation fragments your attention into another app, another notification stream, another silo where messages live or vanish at someone else's discretion. Email, for all its faults, is universal. Send a message to anyone with an address anywhere in the world and it will arrive, routed through a system with no single point of control. This matters. It means you can switch jobs without losing your inbox. It means you can reach someone who refuses to use Meta's products. It means the protocol, not a corporation, defines the rules.
It also means that the one universal communication system carries no guarantee of privacy. When platforms advertise safety, this is not mere marketing. Signal and WhatsApp encrypt every message end to end by default, with no configuration needed. An email, by contrast, is readable by every server it passes through, and for most people there is no practical way to change that. End-to-end encryption for email has been possible for as long as PGP has existed, but never simple enough for ordinary users. This is the same pattern that stalled digital signing: a protocol built for a world where trust was assumed cannot retrofit the guarantees the current world demands.
The platforms see this as a bug. Slack does not want you to email people — it wants you on Slack Connect. Microsoft wants you inside Teams. The strategy is consistent: make the open standard feel dusty and unreliable, then offer a polished alternative that happens to be a moat. It is working. Young professionals entering the workforce often lack a personal email habit. They message, DM, ping — but they do not send mail. Email becomes something for old people and official institutions, reinforcing the perception that it is a chore rather than a tool.
Which brings us to the outlook. Email is not going to die. The infrastructure is too deeply embedded — in how businesses run, legal notices are served, accounts are verified, the machine talks to itself. But its role will keep narrowing, and that is a loss. A protocol that lets anyone reach anyone without an intermediary is a rare thing. Every time a conversation moves from email to a platform, a small piece of that openness is surrendered.
The question is whether email can be rehabilitated before the narrowing becomes irreversible. The technical path exists — better authentication, better clients, AI that understands what matters rather than just filtering what does not. But none of that will matter if the social consensus has already shifted. A protocol is only as useful as the people willing to use it. And right now, the people who would need to save it are busy messaging each other somewhere else.
Over the past few years I've grown increasingly tired of the modern web. Every page loads megabytes of JavaScript just to display text. Tracking scripts. Cookie banners. Autoplaying videos. The list goes on.
So when I sat down to redesign my personal homepage, I set a hard constraint: zero JavaScript in the final output.
This turned out to be far less limiting than I expected. CSS has evolved tremendously — :target and :has() selectors give you navigation and interactivity that once required JS. The "checkbox hack" handles image zoom. The result is a single HTML file under 15KB, fully functional, accessible, and fast.
There's something satisfying about building for the web with the web's native tools rather than abstracting everything behind a framework. It forces you to think about what matters: content, structure, and progressive enhancement.
I don't think this approach is right for every project — but for a personal homepage? It's perfect.