<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Mark Wilson on Medium]]></title>
        <description><![CDATA[Stories by Mark Wilson on Medium]]></description>
        <link>https://medium.com/@mwilson1962?source=rss-88b27f9f5af4------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ZeK2ZGk6TbFR0fcyxE-eew.jpeg</url>
            <title>Stories by Mark Wilson on Medium</title>
            <link>https://medium.com/@mwilson1962?source=rss-88b27f9f5af4------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 16:26:00 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mwilson1962/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[We Thought There Were Two Paths to AI. We Took a Third.]]></title>
            <link>https://medium.com/@mwilson1962/we-thought-there-were-two-paths-to-ai-we-took-a-third-a2cff78f115c?source=rss-88b27f9f5af4------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2cff78f115c</guid>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Mark Wilson]]></dc:creator>
            <pubDate>Fri, 15 May 2026 18:29:44 GMT</pubDate>
            <atom:updated>2026-05-15T18:29:44.546Z</atom:updated>
            <content:encoded><![CDATA[<p>I remember reading about artificial intelligence more than twenty years ago, back when it still felt futuristic.</p><p>At the time, the discussion around AI seemed to split into two camps. One camp believed machines should learn the way humans do: start simple, interact with the world. Build understanding through experience, almost like raising a child.</p><p>The other camp took a far more brute-force approach. Feed the machine enormous amounts of information and let computation do the work.</p><p>Even then, the second approach sounded a little ridiculous to me. The world is too large. Knowledge changes constantly. I remember thinking you cannot possibly hand-feed a machine every fact about reality.</p><p>But I went back recently and checked my memory. It turns out those two camps were real.</p><p>Researchers like Rodney Brooks pushed the idea that intelligence had to be embodied. Machines needed to interact physically with the world, struggle with uncertainty, and learn through experience. Robots like Cog and Kismet were designed around this philosophy.</p><p>At the same time, systems like IBM Deep Blue demonstrated something else entirely. You could achieve astonishing results without anything resembling human understanding if you had enough compute and enough search space.</p><p>Over time, brute force won, or at least appeared to.</p><p>Expert systems mostly collapsed under their own complexity. Handcrafted rules became brittle and difficult to maintain. Developmental robotics moved slowly because physical experience is slow. A robot baby can only experience one second of life per second.</p><p>Meanwhile, compute kept scaling. More processors. More storage. More internet data. More GPUs.</p><p>And eventually, the industry discovered something important:</p><p>You did not need to truly model intelligence if you could approximate the results of intelligence at massive scale.</p><p>That is essentially the path modern AI took. Large language models do not really fit either of the original camps.</p><p>They do not learn like a human child, but they also are not handcrafted encyclopedias full of explicit rules.</p><p>Instead, they absorb statistical patterns from enormous amounts of human-generated data. Books, articles, source code, forum posts, arguments, explanations, documentation. Decades of accumulated human thought compressed into weights inside a neural network.</p><p>That is not the future many people imagined.</p><p>In a strange way, we solved parts of AI not by understanding intelligence better, but by scaling approximation farther than anyone expected.</p><p>And that feels familiar to other areas of computing. In software engineering, the expedient solution often wins first. The hack wins. The thing that gets results now beats the thing that is carefully modeled and deeply understood.</p><p>Until it isn’t. Then comes complexity, and opacity, and systems that nobody fully understands anymore.</p><p>And that raises an interesting question about modern AI. Have we actually created intelligence?</p><p>Or have we created systems that are extraordinarily good at approximating intelligence?</p><p>Those are not necessarily the same thing.</p><p>Current AI systems know an enormous amount about the world, but they do not experience it.</p><p>They know what “pain” means, but they do not avoid pain because they have never suffered damage. They know what gravity is, but they have never fallen down a staircase.</p><p>This is part of what researchers call the Symbol Grounding Problem. Words connect to other words, but not necessarily to lived reality.</p><p>Which may explain why the old “baby” idea is quietly returning. Not as a replacement for large-scale models, but as a complement to them.</p><p>More researchers are exploring embodied AI again. Large models combined with robots. Simulation environments where systems learn through interaction rather than text alone.</p><p>In other words, the field may be circling back toward the idea that intelligence requires more than information.</p><p>Maybe it requires consequences, experience, and failure.</p><p>I do not know whether that path leads to what people would call real intelligence.</p><p>But I do think the history of AI turned out stranger than many of us expected.</p><p>We thought we were choosing between two paths. Instead, we built a third one.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2cff78f115c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Most embedded systems don’t fail, they calcify.]]></title>
            <link>https://medium.com/@mwilson1962/most-embedded-systems-dont-fail-they-calcify-b89fe13e0770?source=rss-88b27f9f5af4------2</link>
            <guid isPermaLink="false">https://medium.com/p/b89fe13e0770</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Mark Wilson]]></dc:creator>
            <pubDate>Thu, 26 Mar 2026 19:34:40 GMT</pubDate>
            <atom:updated>2026-03-31T19:33:36.540Z</atom:updated>
            <content:encoded><![CDATA[<p>Over time, they turn into what I think of as <strong>coral reef software</strong>: layer on layer of features, fixes, workarounds, and “just one more change.”</p><p>It still works, but it becomes harder and harder to understand, change, or trust.</p><p>And there isn’t enough late-night pizza to fix that.</p><p>It isn’t that engineers are bad (and easily bribed with late-night pizza), it happens because modularization was never strong enough to begin with.</p><p>If a system is not properly modular, changes ripple across unrelated components, concurrency leaks into places it doesn’t belong, testing requires the entire system to be running, and behavior becomes harder to reason about.</p><p>So teams compensate with more heroic effort and more hours. Maybe some pizza bought by management before they all go home.</p><p>Good modularization prevents this. Not by organizing files or classes, but by enforcing real boundaries:</p><ul><li>clear data flow between components</li><li>explicit communication (queues, messages — not shared state)</li><li>centralized ownership of execution</li><li>components that do one thing and do not reach across boundaries</li></ul><p>When those modules boundaries are well designed:</p><ul><li>systems can be developed on a host before hardware is ready</li><li>concurrency stays visible and controlled</li><li>parts can be tested in isolation</li><li>changes stay local instead of spreading</li></ul><p>Without that structure, systems don’t collapse, they accrete more layers of dead stuff.</p><p>And over time, they become difficult to maintain, extend, or even understand. But at least there’s pizza!</p><p>More reading on my blog: <a href="https://markvtechblog.wordpress.com/my-books-and-articles/">my book and selected writings</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b89fe13e0770" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[UML and the Wrong Level of Abstraction]]></title>
            <link>https://medium.com/@mwilson1962/uml-and-the-wrong-level-of-abstraction-aaa871d03c24?source=rss-88b27f9f5af4------2</link>
            <guid isPermaLink="false">https://medium.com/p/aaa871d03c24</guid>
            <category><![CDATA[code-generation]]></category>
            <category><![CDATA[uml-diagrams]]></category>
            <category><![CDATA[uml-tool]]></category>
            <dc:creator><![CDATA[Mark Wilson]]></dc:creator>
            <pubDate>Mon, 23 Mar 2026 13:45:37 GMT</pubDate>
            <atom:updated>2026-03-23T13:45:37.250Z</atom:updated>
            <content:encoded><![CDATA[<p>Originally published in my <a href="https://markvtechblog.wordpress.com/2026/03/23/why-uml-is-a-bad-abstraction-mechanism/">blog</a>.</p><p>UML was supposed to replace code as the primary artifact in software development. It never came close.</p><p>I remember a period in the late 1990s and early 2000s, the software industry placed enormous hopes on UML. The Unified Modeling Language was supposed to raise the level of abstraction in software development. Instead of writing code directly, engineers would design systems using models and diagrams. Tools would generate code from those models, and development would proceed through something called <em>round-trip engineering</em>, where diagrams and source code remained synchronized.</p><p>It didn’t work out; diagram/code synchronization didn’t work well, and the tools were complex.</p><p>Today UML diagrams still exist, but they are usually used as documentation or as informal sketches during design discussions. Very few teams treat UML models as the primary artifact from which software is generated. The code remains the source of truth.</p><h3>The Wrong Level of Abstraction</h3><p>A good abstraction removes unnecessary detail.</p><p>UML was supposed to abstract away programming languages, but in actually most UML models describe the same concepts that appear in the code:</p><ul><li>classes</li><li>attributes</li><li>methods</li><li>inheritance</li><li>visibility</li></ul><p>In other words, UML diagrams often represent the structure of the programming language itself.</p><p>If a model already specifies classes, members, methods, and relationships, then most of the work of programming has already been done. At that point the diagram is not operating at a higher level of abstraction. It is simply expressing the same ideas in a different notation.</p><p>You may as well write the code yourself!</p><p>This is one of the fundamental reasons UML-based code generation struggled. The models were already so close to the programming language that they provided very little leverage.</p><h3>The Round-Trip Engineering Problem</h3><p>The most ambitious UML workflows relied on round-trip engineering:</p><p><strong>UML Model -&gt; Generate Code -&gt; Modify Code -&gt; Synchronize Model</strong></p><p>In theory, diagrams and code would stay synchronized automatically, but in reality this workflow was brittle and frustrating. I remember trying to use this stuff and not enjoying the experience at all; the tools generated some fugly code that I didn’t want to touch.</p><p>Developers modify code while working and diagrams quickly drift out of date. Keeping the two representations synchronized requires complex tooling and discipline that most teams cannot sustain. Eventually the diagrams fall behind the code and become inaccurate. Most organizations abandoned the idea of round-trip engineering.</p><h3>What Actually Works</h3><p>The only sustainable way to keep diagrams synchronized with software is to generate the diagrams from the code. Documentation tools such as Doxygen do this. They parse source code and generate diagrams showing class relationships or module structure. In this workflow, the source code remains the single source of truth and the diagrams are derived artifacts.</p><p><strong>Source Code -&gt; Documentation Tool -&gt; Generated UML Diagrams</strong></p><p>This approach works because it does not require developers to maintain two representations of the same system. When the code changes, the diagrams sync to it via the tool. One way engineering.</p><h3>What Real Abstraction Looks Like</h3><p>The deeper lesson is about abstraction. If we want to model software systems effectively, the model must describe the <em>system itself</em>, not the programming language used to implement it.</p><p>Consider a system that processes sensor data through a pipeline. A useful model of that system might look like this:</p><pre>measurements:</pre><pre>- Temperature</pre><pre>- Humidity</pre><pre>queues:</pre><pre>- TemperatureQueue</pre><pre>stages:</pre><pre>- TemperatureSensor</pre><pre>- Logger</pre><p>This description captures the structure of the system:</p><ul><li>what data exists</li><li>how it flows</li><li>which components process it</li></ul><p>There is no mention of classes or inheritance. Those details belong in the implementation, not in the model.</p><p>A model that describes system concepts can generate useful infrastructure automatically, and in multiple languages if that makes sense.</p><h3>Where UML Still Helps</h3><p>This doesn’t mean that diagrams are useless. UML diagrams can still be helpful for:</p><ul><li>communicating architecture</li><li>documenting relationships between components</li><li>sketching ideas during design discussions</li><li>drawing state and sequence diagrams</li></ul><p>But they are rarely the right foundation for code generation or system modeling.</p><h3>Raising the Level of Abstraction</h3><p>Software engineering constantly tries to move to higher levels of abstraction. Assembly language replaced machine code. High-level languages replaced assembly. Frameworks and libraries abstract away common infrastructure. Modeling systems should do the same.</p><p>The lesson from UML is that models must operate at a higher level than the programming language itself.</p><p>If the model is just describing classes, attributes, and methods, it does not represent a proper abstraction; it has only drawn the programming language with boxes and arrows.</p><p>This is where code generation becomes powerful. We don’t generate code from class diagrams, we generate infrastructure from a model that actually describes the system.</p><p>See my <a href="https://markvtechblog.wordpress.com/2024/04/28/code-generation-in-python-with-jinja2/">article</a> on code generation.</p><p>This is the problem I’m tackling in my upcoming book on code generation: raising the level of abstraction <em>above</em> the programming language, not just drawing it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aaa871d03c24" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I Do Host First Development]]></title>
            <link>https://medium.com/@mwilson1962/why-i-do-host-first-development-9c589ae6d73c?source=rss-88b27f9f5af4------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c589ae6d73c</guid>
            <category><![CDATA[system-design-concepts]]></category>
            <category><![CDATA[c-plus-plus-language]]></category>
            <category><![CDATA[embedded-systems]]></category>
            <dc:creator><![CDATA[Mark Wilson]]></dc:creator>
            <pubDate>Tue, 17 Mar 2026 16:53:22 GMT</pubDate>
            <atom:updated>2026-03-17T16:53:22.180Z</atom:updated>
            <content:encoded><![CDATA[<p>Why I Do Host First Development</p><p>A lot of embedded development is slowed down by simple logistics.</p><p>In my work with embedded systems, I realized that the whole code, compile, load, run and debug on hardware is a tedious, slow, and error prone way to develop embedded code.</p><p>Maybe full or even partial hardware isn’t available, or there is not enough hardware for all the developers. Cue “let’s make yet another spreadsheet!”.</p><p>Maybe there isn’t enough debugging equipment such as JTAG probes, oscilloscopes, etc. for every team member. The Yocto image may be missing something basic, such as a UART. FPGA drops may be delayed.</p><p>I have seen all of these issues firsthand.</p><p>For these reasons, I prefer to do as much host-first development as is practical.</p><p>Host-first development means building and testing as much of the system as possible on a normal Linux machine before running on the final embedded hardware.</p><p>It doesn’t replace hardware testing. It does not magically solve every embedded problem. But it does let you develop and exercise a surprising amount of the software before the target environment is fully ready: data flow, protocol parsing, concurrency, control logic, failure handling, and system composition.</p><p>In one project I worked with a GPS receiver over UART. The receiver communicated with a complex binary protocol to provide position, time, and status information.</p><p>Even though I had the hardware development kit available, most of the software development did not actually require it. Once I captured representative binary data logs from the device, I could feed those logs into the parsing and processing pipeline on a Linux host.</p><p>That allowed me to develop and test the message framing, checksum validation, parsing, and downstream processing logic without always having the kit.</p><p>In another instance I had to integrate an IMU that streamed binary telemetry packets over UDP. The device itself was often available, but again most development did not require the live hardware.</p><p>Once packet captures were recorded, the decoding and processing code could be developed on a Linux host by replaying the captured traffic. Synthetic packets could also be generated to test edge cases that would be difficult to reproduce with the real sensor.</p><p>In practice this usually means writing the code so that the source can be swapped easily. During host-first development the input might come from a file, a test generator, or the actual device. On the final system it comes from the real device.</p><p>An important aspect of this approach is that the host-side software was not just a prototype.</p><p>The parsing, framing, and processing logic was implemented as portable modules or libraries. Those same modules could later be cross-compiled for the embedded target and connected to the real hardware interfaces.</p><p>An added benefit: those modules could be used at any time for verifying hardware, and for automated testing pipelines.</p><p>Host-first development does not eliminate the need for real hardware. Eventually the code must run on the device, interact with real signals, and deal with the messy realities of timing, electrical interfaces, and integration.</p><p>But a surprising amount of embedded software does not actually require the hardware to exist yet. Parsing, framing, control logic, data pipelines, and system behavior can often be developed and tested on a normal Linux machine.</p><p>When the hardware finally arrives, the software is not starting from scratch.</p><p>I discuss this host-first approach and the architecture that supports it in more detail in my book <a href="https://leanpub.com/designingdeterministicsystems"><em>Designing Deterministic Systems with Modern C++</em></a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c589ae6d73c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[C++ Object Construction Techniques]]></title>
            <link>https://medium.com/@mwilson1962/c-object-construction-techniques-22798454feba?source=rss-88b27f9f5af4------2</link>
            <guid isPermaLink="false">https://medium.com/p/22798454feba</guid>
            <category><![CDATA[fluent-builder-pattern]]></category>
            <category><![CDATA[factory-method]]></category>
            <category><![CDATA[cplusplus]]></category>
            <category><![CDATA[fluent-interface]]></category>
            <category><![CDATA[object-construction]]></category>
            <dc:creator><![CDATA[Mark Wilson]]></dc:creator>
            <pubDate>Tue, 10 Mar 2026 16:39:52 GMT</pubDate>
            <atom:updated>2026-03-10T16:39:52.800Z</atom:updated>
            <content:encoded><![CDATA[<p>In previous articles, <a href="https://medium.com/@mwilson1962/a-c-value-type-should-never-have-an-invalid-state-7740b42b2c32">A C++ Value Type Should Never Have an Invalid State</a> and <a href="https://medium.com/@mwilson1962/entity-object-construction-in-c-establish-identity-at-creation-9b4947835255">Entity Object Construction in C++: Establish Identity at Creation</a>, I argued that C++ object invariants should be fully established at the moment of creation. If an object exists, it should represent a meaningful and usable state.</p><p>Different systems impose different constraints. Construction may fail, and sometimes complex configuration is required to create a usable object.</p><p>In this article I will survey several C++ construction techniques, and discuss how each approach meets different architectural requirements. These techniques are different paths to the same goal: ensuring that objects begin their lifetime in a valid and usable state.</p><p>We will discuss four methods for constructing valid C++ object instances:</p><ul><li>Direct Constructors</li><li>Static Factory Function Construction<br>- Return std::optional<br>- Return std::expected</li><li>Builder/Fluent Construction</li></ul><h3>Direct Constructors</h3><p>We’ll start with the simplest construction technique:</p><pre>class Temperature<br>{<br>public:<br>    explicit Temperature(double celsius)<br>        : m_celsius(celsius)<br>    {<br>        if (!std::isfinite(celsius))<br>        {<br>            throw std::invalid_argument(&quot;Invalid temperature&quot;);<br>        }<br>    }<br><br>private:<br>    double m_celsius;<br>};</pre><p>This variation is used when invariants can be checked immediately, exceptions are acceptable, and construction is simple.</p><h3>Static Factory Functions</h3><p>Use this technique when an object has multiple named variants. The name of a factory method provides a “semantic handle” for the object, in this case<em> localhost()</em> and <em>any(). </em>Note that the default constructor is made private; the compiler will enforce use of the factory functions. Neither <em>localhost()</em> nor<em> any()</em> can fail and will never throw an exception.</p><pre>class HostAddress<br>{<br>public:<br>    static HostAddress localhost() noexcept<br>    {<br>        return HostAddress(0x7F000001);<br>    }<br><br>    static HostAddress any() noexcept<br>    {<br>        return HostAddress(0);<br>    }<br><br>private:<br>    explicit HostAddress(uint32_t addr)<br>        : m_addr(addr)<br>    {}<br><br>    uint32_t m_addr;<br>};</pre><p>For factory methods than may fail, we can return <em>std::optional&lt;HostAddress&gt;</em>:</p><pre>static std::optional&lt;HostAddress&gt; parse(std::string_view text)<br>{<br>    uint32_t addr;<br>    if (!parse_ipv4(text, addr))<br>        return std::nullopt;<br><br>    return HostAddress(addr);<br>}</pre><p>The <em>parse_ipv4()</em> method could easily fail; any ill-formed IPv4 address will fail to parse properly. We could throw an exception, but particularly in the embedded world exceptions are generally forbidden. <em>std::optional&lt;T&gt;</em> (C++17 and up) is a container that holds either a value of type T or nothing at all. It is used to represent optional data, making code safer and more readable.</p><pre>if ( !HostAddress::parse(&quot;a.b.c.d&quot;).has_value() )<br>{<br>     // parsing failed<br>}</pre><p>A related standard library type is</p><pre>std::expected&lt;HostAddress, ParseError&gt;</pre><p>Use this when you want to provide more detailed error information.</p><h3>Fluent Builder Construction</h3><p>Some objects have long parameter lists, some of which may be optional. This is difficult to read and error prone.</p><p>We might start with this:</p><pre>SensorConfig(int sample_rate, int timeout_ms, bool enable_filter, ....)</pre><p>This form makes it difficult to provide good values for optional parameters, and is tedious to use and read. Instead, we can use a <strong><em>Builder</em></strong> to separate object configuration from construction:</p><pre>SensorConfig cfg =<br>    SensorConfig::builder()<br>        .sample_rate(100)<br>        .timeout_ms(50)<br>        .enable_filter(true)<br>        .build();</pre><p>This is known as a <em>Fluent Interface</em>. It is easy to read and makes parameters obvious.</p><p>This technique uses <em>method chaining</em>, in the same way as <em>iostream</em>. Each method in the builder returns a reference to the builder object (<em>SensorConfig</em>), allowing additional configuration methods to be chained together.</p><p>The final <em>build()</em> method constructs the object, ensuring invariants are satisfied. The builder object provides good defaults for parameters that are not “chained in”. The built object must still satisfy all invariants.</p><h3>A Note on Default Constructors</h3><p>Default construction is appropriate when the default state is meaningful. If an object can’t represent a valid, usable state, no default constructor should be provided.</p><h3>Closing</h3><p>Regardless of the construction technique used, our goal is the same: when an object is born, its invariants should be already satisfied.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=22798454feba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Entity Object Construction in C++: Establish Identity at Creation]]></title>
            <link>https://medium.com/@mwilson1962/entity-object-construction-in-c-establish-identity-at-creation-9b4947835255?source=rss-88b27f9f5af4------2</link>
            <guid isPermaLink="false">https://medium.com/p/9b4947835255</guid>
            <category><![CDATA[data-modeling]]></category>
            <category><![CDATA[object-oriented]]></category>
            <category><![CDATA[cplusplus]]></category>
            <dc:creator><![CDATA[Mark Wilson]]></dc:creator>
            <pubDate>Fri, 27 Feb 2026 17:24:52 GMT</pubDate>
            <atom:updated>2026-02-27T17:24:52.508Z</atom:updated>
            <content:encoded><![CDATA[<p>In a <a href="https://medium.com/@mwilson1962/a-c-value-type-should-never-have-an-invalid-state-7740b42b2c32">previous article</a>, I argued that a value type should never have an invalid state. If it exists, it must represent something meaningful that won’t cause undefined behavior.</p><p>But not every object in a system is a value-type; some things are entity-types.</p><p>What’s the difference? A value type is defined entirely by its state (think an <em>int</em> type), while an entity is defined by its identity. State may change over time, but identity must not.</p><p>Two <a href="https://medium.com/@mwilson1962/a-c-value-type-should-never-have-an-invalid-state-7740b42b2c32">HostAddress objects</a> representing 192.168.1.10 are interchangeable, but two physical devices running the same firmware with the same configuration and IP address are not.</p><p>Identity matters in this example. A device may have identifying information assigned at manufacture, such as:</p><ul><li>A serial number</li><li>A hardware MAC address</li></ul><p>That information is generally immutable.</p><p>Even if two devices temporarily share identical configuration state such as firmware version, IP address, hostname, they are still distinct entities if their identity differs. Configuration can change, but identity cannot. What makes it the same entity is not a memory address, but its identity.</p><h3>A Bad Example: Identity Assigned After Construction</h3><p>Years ago, I also wrote entity-like classes with a “construction phase” followed by an “initialization phase.”</p><p>Something like this:</p><pre>class Device<br>{<br>public:<br>    Device(); // exists, but has no identity yet<br><br>    void setIdentity(uint64_t serialNumber); // or setUuid(...)<br>    bool isValid() const noexcept;<br><br>    uint64_t serialNumber() const noexcept;<br><br>private:<br>    uint64_t mSerialNumber;<br>    bool     mHasIdentity;<br>};</pre><p>This looks flexible. It “works.” It is also a modeling smell. This class allows a Device object to exist before it has identity.</p><p>That means every call site must follow a convention:</p><ul><li>construct it</li><li>assign identity</li><li>then use it</li><li>and maybe check isValid() everywhere</li></ul><p>Nothing prevents misuse:</p><pre>Device d;<br>doSomethingWith(d.serialNumber()); // what is this?</pre><p>Once again, the entity behaves like a state machine:</p><ul><li>constructed</li><li>maybe assigned identity</li><li>maybe valid</li><li>maybe not</li></ul><p>That is fragile.</p><h3>Refactor: Construction Establishes Identity</h3><p>If a thing is an entity, it should not exist without identity.</p><p>Identity should be required at construction, and it should not be mutable.</p><pre>class Device<br>{<br>public:<br>    Device() = delete;<br><br>    explicit Device(uint64_t serialNumber) noexcept<br>        : mSerialNumber(serialNumber)<br>    {<br>    }<br><br>    Device(Device&amp;&amp;) noexcept = default;<br>    Device&amp; operator=(Device&amp;&amp;) noexcept = default;<br><br>    Device(const Device&amp;) = delete;<br>    Device&amp; operator=(const Device&amp;) = delete;<br><br>    friend bool operator==(const Device&amp; a, const Device&amp; b) noexcept<br>    {<br>        return a.mSerialNumber == b.mSerialNumber;<br>    }<br><br>    friend bool operator!=(const Device&amp; a, const Device&amp; b) noexcept<br>    {<br>        return !(a == b);<br>    }<br><br>    uint64_t serialNumber() const noexcept<br>    {<br>        return mSerialNumber;<br>    }<br><br>private:<br>    const uint64_t mSerialNumber;<br>};</pre><p>Note:</p><ul><li>no default constructor</li><li>no setIdentity()</li><li>no isValid() flag</li></ul><p>If the object exists, it has identity.</p><h3>Equality and Comparison</h3><p>For entities, equality should be based on identity. Two entities are equal if, and only if, they represent the same identity. In C++, that means <em>operator==</em> should compare the identity field:</p><pre>friend bool operator==(const Device&amp; a, const Device&amp; b) noexcept<br>{<br>    return a.mSerialNumber == b.mSerialNumber;<br>}</pre><p><em>State comparison</em> is a different issue. Two devices may have identical configuration state and still not be the same entity. If needed, make configuration comparison explicit:</p><pre>bool same_state_as(const Device&amp; other) const noexcept;</pre><p>Don’t overload the meaning of equality. For values, equality means “same state”, for entities equality means “same identity”.</p><h3>Copy and Move Semantics</h3><p>Value types are naturally copyable. If you copy an int, you get another int with the same value. That makes sense.</p><p>If you copy a HostAddress, you get another independent value representing the same address. That also makes sense.</p><p>Entities are different. Copying an entity creates ambiguity.</p><p>If we allowed copying:</p><pre>Device a(42);<br>Device b = a;  // what does this mean?</pre><p>Now we have two independent C++ objects representing the same identity.</p><p>Is that intended?</p><p>Often, the answer is no.</p><p>For that reason, entities are frequently non-copyable and move-only:</p><pre>Device(const Device&amp;) = delete;<br>Device&amp; operator=(const Device&amp;) = delete;<br><br>Device(Device&amp;&amp;) noexcept = default;<br>Device&amp; operator=(Device&amp;&amp;) noexcept = default;</pre><p>Moving transfers ownership or responsibility; copying an entity duplicates representation and can blur intent.</p><p>This is not a hard rule; some architectures allow multiple handles to the same entity, but it is a useful default stance.</p><p>Values are freely copyable, while entities require more care.</p><h3>Closing</h3><p>A value must be valid when it exists; an entity must have identity when it exists. In both cases, construction establishes correctness.</p><p>If an object can exist without being complete , whether that means “valid state” or “stable identity”, then the type is modeling a phase of life instead of a concept.</p><p>Construction is not an initialization step, it is a guarantee.</p><p>Invalid states are deferred bugs; mutable identity creates confusion.</p><p>Model the invariant at the type boundary. Let the compiler enforce it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9b4947835255" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A C++ Value Type Should Never Have an Invalid State]]></title>
            <link>https://medium.com/@mwilson1962/a-c-value-type-should-never-have-an-invalid-state-7740b42b2c32?source=rss-88b27f9f5af4------2</link>
            <guid isPermaLink="false">https://medium.com/p/7740b42b2c32</guid>
            <category><![CDATA[c-plus-plus-language]]></category>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Mark Wilson]]></dc:creator>
            <pubDate>Thu, 12 Feb 2026 19:05:01 GMT</pubDate>
            <atom:updated>2026-02-12T19:05:01.134Z</atom:updated>
            <content:encoded><![CDATA[<p>A C++ Value Type Should Never Have an Invalid State</p><p>Think about <em>int</em>; there is no such thing as an invalid <em>int</em>. If an <em>int</em> variable exists, it represents a valid integer. Same with <em>double</em>. You don’t have to verify the validity of a basic C++ type; it is always valid.</p><p>We have all defined custom C++ values with <em>class</em> or <em>struct</em>. Many times (I’ve done this) there are one or more constructors (perhaps a default constructor) and some sort of <em>isValid() </em>method that the caller is required to invoke at run-time to ensure validity of the value.</p><p>This is a mistake in modeling.</p><p>A value type should represent a complete, meaningful domain value.</p><p>Years ago, I wrote something like this:</p><pre>class HostAddress<br>{<br>public:<br>    enum SpecialAddress<br>    {<br>        Null,      // ???<br>        LocalHost, // 127.0.0.1<br>        Any        // 0.0.0.0<br>    };<br><br>    HostAddress();<br>    HostAddress(const std::string&amp; address);<br>    HostAddress(uint32_t address);<br>    HostAddress(SpecialAddress address);<br><br>    bool isValid() const;<br><br>    uint32_t number() const;<br><br>private:<br>    uint32_t    mSockaddr;<br>    std::string mStringForm;<br>    bool        mIsValidFlag;<br>};</pre><p>It looks flexible and convenient, and seems to represent an IPv4 host address. We can construct a <em>LocalHost</em>, <em>Any</em>, or <em>Null</em> <em>HostAddress</em>, or give it a specific IP address in string or integer form.</p><p>What could go wrong?</p><p>This contract allows a user to create an instance of <em>HostAddress</em> that does not represent a real address.</p><p>If a user provides an invalid IP address string, for instance, the instance may exists, but not represent a valid address.</p><p>After construction, the user is required to use <em>isValid() </em>(or some other validity condition)<em> </em>everywhere the value is used.</p><p>Validity is not enforced by construction. It is enforced by run-time convention.</p><p>Conventions like this are fragile.</p><p>Why does this matter?</p><p>When a type requires an <em>isValid()</em> check, the compiler can’t help you.</p><p>Nothing prevents this:</p><pre>HostAddress addr(&quot;no-an-ip&quot;);<br>socket.connect(addr.number()); // What happens here?</pre><p>The compiler happily allows construction. The object exists, but the burden of correctness is now the responsibility of the caller.</p><p>This instance of <em>HostAddress</em> is behaving like a state machine:</p><ul><li>constructed</li><li>maybe parsed</li><li>maybe valid</li><li>maybe not</li></ul><p>This is way too complex for a value type.</p><h3>Refactor to “Construction Establishes Validity”</h3><p>The problem with the original design is that construction does not guarantee that an instance of <em>HostAddress</em> has any meaning.</p><p>A value type should be completely valid the moment it exists, and should represent a real IP address.</p><p>If parsing fails, no object should exist.</p><p>Here’s how I’d write this today:</p><pre>class HostAddress<br>{<br>public:<br>    static HostAddress any() noexcept;        // 0.0.0.0<br>    static HostAddress localhost() noexcept;  // 127.0.0.1<br><br>    static std::optional&lt;HostAddress&gt;<br>        parse(std::string_view s) noexcept;<br><br>    uint32_t v4_u32_be() const noexcept { return m_v4_be; }<br>    std::string to_string() const;<br><br>private:<br>    explicit HostAddress(uint32_t v4_be) noexcept<br>        : m_v4_be(v4_be)<br>    {<br>    }<br><br>    const uint32_t m_v4_be;<br>};</pre><p>Note what is NOT here:</p><ul><li>no default constructor</li><li>no concept of null</li><li>no private validity flag</li></ul><p>Every <em>HostAddress</em> instance represents a valid IPv4 address.</p><p>If parsing fails:</p><pre>auto addr = HostAddress::parse(&quot;not-an-ip&quot;);<br>if (!addr)<br>{<br>    // No HostAddress exists.<br>}</pre><p>The type remains pure, and absence is modeled explicitly.</p><p><em>std::optional</em> represents absence explicitly. It means “there may or may not be a value here.” That is very different from embedding a “null” or “invalid” state inside the value type itself.</p><p>If parsing fails, <em>parse()</em> does not construct a broken <em>HostAddress</em>. It returns <em>std::nullopt</em>. No object exists. There is nothing to misuse.</p><p>Absence is modeled at the boundary, not hidden inside the type.</p><h3>A Value Type is Either Valid or It Does Not Exist</h3><p>A value type should behave like int.</p><p>If it exists, it represents a meaningful value. If it cannot represent one, it should not exist.</p><p>When validity becomes a runtime convention instead of a construction guarantee, the compiler stops protecting you. The burden shifts to discipline, documentation, and careful review.</p><p>By making construction establish validity, we allow the compiler to enforce more of our intent. We remove invalid states instead of detecting them. We simplify reasoning about the code.</p><p>Invalid states are not flexibility. They are deferred bugs.</p><p>This distinction becomes even more important when we move from value types to entities — where identity, not just state, defines correctness.</p><p>But that is for the next article.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7740b42b2c32" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Working with LLMs Like an Engineer]]></title>
            <link>https://medium.com/@mwilson1962/working-with-llms-like-an-engineer-c5b324def354?source=rss-88b27f9f5af4------2</link>
            <guid isPermaLink="false">https://medium.com/p/c5b324def354</guid>
            <category><![CDATA[technical-writing]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Mark Wilson]]></dc:creator>
            <pubDate>Thu, 22 Jan 2026 15:45:27 GMT</pubDate>
            <atom:updated>2026-01-22T15:51:21.559Z</atom:updated>
            <content:encoded><![CDATA[<p>I am writing a technical <a href="https://leanpub.com/buildingembeddedsystemsonlinuxamoderncapproach">book</a>, with working architecture and code. As of this writing I’m up to 9 chapters. In the process of writing I have evolved several design decisions.</p><p>Naturally, I’ve been using an LLM to help reason about designs, validate trade-offs, and refine explanations. And for a while, it was frustrating:</p><ul><li>“It forgot what we decided.”</li><li>“It contradicted itself across sub-chats.”</li><li>“It drifted from the design.”</li><li>“It rewrote code that was already correct.”</li></ul><p>At first, I assumed this was a limitation of the tool, or that I was just hitting the edges of what these systems can do. I was wrong, The problem wasn’t the model, the problem was how I was using it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ato1aBNg4DXLd_EEQxj4zA.png" /></figure><h3>The Wrong Assumption I Didn’t Know I Was Making</h3><p>I was treating the LLM like a collaborator who remembered shared context.</p><p>I had a main chat and project sub-chats. I had ongoing threads where I assumed prior decisions carried forward. I assumed that because <em>I</em> remembered the design, the model did too.</p><p>That assumption was completely false.</p><p>An LLM does not remember decisions.<br> It does not infer which context is authoritative.<br> It does not preserve intent across conversations.</p><p>It reasons only over what is explicitly present in the active context window.</p><p>Once I realized that, everything clicked.</p><h3>LLMs Are Not Teammates. They’re Systems.</h3><p>The mistake was that I was relying on hidden state, the same kind that so often creeps into real systems. I had effectively built a fragile workflow with unexplained behavior and a lot of debugging and backtracking.</p><blockquote>Large language models behave more like compilers than collaborators.</blockquote><p>They do not remember decisions, infer authority, or preserve invariants unless those things are made explicit. Most frustration engineers experience with AI tools comes not from model quality, but from treating a deterministic system as if it were a human teammate.</p><p>The AI will very confidently create plausible, even good, code that is completely different from what you had already established as “canonical”.</p><h3>The Breakthrough: Clarifying the Contract</h3><p>The turning point came when I stopped trying to “continue” conversations and instead clarified the contract explicitly.</p><p>I asked the model, directly, how to keep us synchronized while writing a book with evolving code and design constraints.</p><p>The answer was straightforward:</p><ul><li>Provide authoritative context explicitly</li><li>Declare what was canonical</li><li>Replace context deliberately instead of assuming continuity</li></ul><p>Once I did that, the behavior changed immediately.</p><h3>The Pattern That Works</h3><p>Here is the pattern I now use consistently.</p><p>At the start of a working session, I inject context deliberately and completely.</p><ul><li>One block that defines book-wide design decisions, terminology, and constraints</li><li>One block that contains canonical code listings.</li></ul><p>I label them clearly and state that they are authoritative.</p><p>After that, I work incrementally. If something changes, I replace that section explicitly and say so.</p><p>This feels obvious in hindsight because it mirrors how we already build systems:</p><ul><li>Single source of truth</li><li>Explicit ownership</li><li>Controlled mutation</li><li>No reliance on implicit state</li></ul><p>Once I adopted this pattern, the “forgetting” stopped. The drift stopped. The contradictions stopped.</p><blockquote>Nothing about the model changed, but my workflow did.</blockquote><h3>This Is Not About ChatGPT vs Claude vs Gemini</h3><p>This behavior is not specific to one model.</p><p>Different systems have different styles. Some are more cautious. Some ask more questions. Some sound more confident.</p><p>None of them preserve intent unless you make it explicit.</p><p>Switching models will not fix a broken interaction model.</p><h3>Why This Matters for Engineers</h3><p>Engineers are particularly prone to frustration with LLMs because we expect systems to behave deterministically once constraints are set.</p><p>The irony is that LLMs <em>do</em> behave predictably once you treat context as input instead of conversation.</p><p>This is not about better prompts, it’s about better inputs.</p><h3>The Real Lesson</h3><p>This was not an AI failure, it was a tooling literacy gap.</p><p>I projected human collaboration semantics onto a system that does not work that way. Once I corrected that mental model, the tool became dramatically more effective.</p><p>LLMs are powerful. They are also literal. If you want them to work like engineering tools, you have to use them like engineering tools.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c5b324def354" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Will Get Better. That Doesn’t Mean It Will Replace Engineering Judgment.]]></title>
            <link>https://medium.com/@mwilson1962/ai-will-get-better-that-doesnt-mean-it-will-replace-engineering-judgment-5c4308005ecf?source=rss-88b27f9f5af4------2</link>
            <guid isPermaLink="false">https://medium.com/p/5c4308005ecf</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Mark Wilson]]></dc:creator>
            <pubDate>Tue, 20 Jan 2026 19:13:41 GMT</pubDate>
            <atom:updated>2026-01-20T19:13:41.808Z</atom:updated>
            <content:encoded><![CDATA[<p>Whenever the topic of AI comes up in engineering circles, the conversation tends to polarize quickly.</p><p>On one side are claims that AI will soon design, build, and maintain complex systems on its own.<br> On the other are blanket dismissals of AI as a fad or a threat.</p><p>Both positions miss something important.</p><p>Yes, AI will continue to dramatically improve. But that does not imply it will autonomously produce complex systems of lasting value.</p><h3>The Assumption Behind “AI Will Do Everything”</h3><p>Most arguments that AI will replace engineering rely on an unstated assumption:</p><blockquote><em>Better pattern completion will eventually turn into understanding, judgment, and responsibility.</em></blockquote><p>That assumption has not been demonstrated.</p><p>Today’s systems:</p><ul><li>model correlations, not causality</li><li>optimize likelihood, not correctness</li><li>generate coherence, not intent</li><li>respond to prompts, not environments</li></ul><p>Scaling these properties improves fluency; it does not automatically produce agency.</p><h3>Why Complex Systems Resist Full Automation</h3><p>Complex systems are not built by translating complete specifications into code. They are built through <strong>constraint discovery</strong> over time.</p><p>Many of the most important constraints in real systems:</p><ul><li>are not known at the start</li><li>emerge only through partial implementation</li><li>are revealed by failure, not planning</li><li>conflict with one another in non-technical ways</li></ul><p>Engineering judgment lives in that gap.</p><p>AI can <em>assist</em> with exploration.</p><p>There is no objective function that encodes:</p><ul><li>which trade off is acceptable</li><li>which shortcut is dangerous</li><li>which technical debt is survivable</li><li>which failure modes matter politically, legally, or ethically</li></ul><p>Those decisions remain human because the consequences are human.</p><h3>Where Did Junior Engineers Go?</h3><p>Junior engineers didn’t disappear. The <em>path</em> that used to turn juniors into trusted engineers eroded, and AI exposed it.</p><p>Junior engineers were given rote mechanical work because it gave them experience with real systems. The repetition was a pretext to observe how decisions were made, how trade offs were argued, and how failures were handled.</p><p>Over time, that changed.</p><p>Teams optimized for throughput instead of mentorship.<br> Systems became more abstract and more siloed.<br> Context retreated into the heads of a few senior engineers.<br> Remote work removed informal learning and osmosis.</p><p>By the time AI arrived, many juniors were already isolated from judgment-bearing work.</p><p>AI didn’t remove junior engineers.<br> It removed the last justification for giving someone low-context, mechanical tasks and calling it “experience.”</p><h3>The Cog Illusion</h3><p>In many jobs I’ve worked, I wasn’t treated as an engineer with specific strengths, limits, and judgment. I was treated as a <strong>generic cog, </strong>someone management assumed could be dropped into any problem and produce value on demand.</p><p>I couldn’t and still can’t. No engineer can.</p><p>Engineering value comes from accumulated context, domain understanding, and judgment. Not from interchangeable labor.</p><p>What’s striking is how often AI is now discussed in exactly the same terms.</p><p>Management talks about AI as if it were:</p><ul><li>infinitely flexible</li><li>context-free</li><li>interchangeable across domains</li><li>capable of replacing judgment with specification</li></ul><p>That was never true of people.<br> It isn’t true of AI.</p><p>The same misunderstanding that reduced engineers to cogs is now being projected onto a tool.</p><h3>The Management Fantasy</h3><p>When management believes they can fully specify a complex system and have AI build something of lasting value, they are living in a fantasy.</p><p>The danger is not that AI will fail, but rather that it will succeed just enough to be dangerously plausible, seemingly eliminating the need for senior engineer judgment.</p><h3>What AI Is Actually Good At</h3><p>AI is very effective at:</p><ul><li>eliminating mechanical work</li><li>generating scaffolding and boilerplate</li><li>accelerating iteration</li><li>surfacing alternatives</li><li>acting as an editor and critic</li></ul><p>I use it extensively this way while writing a technical book on embedded systems and modern C++ design, <a href="https://leanpub.com/buildingembeddedsystemsonlinuxamoderncapproach"><strong>Designing Deterministic Systems with Modern C++</strong></a>. I’m using it to help me write this article.</p><p>It does not replace thinking.<br> It removes friction around thinking.</p><h3>A Familiar Pattern</h3><p>Every major tooling shift in engineering has followed the same arc:</p><ul><li>rote work loses value</li><li>understanding gains value</li><li>shallow competence is exposed</li><li>judgment becomes the differentiator</li></ul><p>Compilers, higher-level languages, IDEs, code generation — all followed this pattern.</p><p>AI extends it further, faster, and more visibly.<br> <br> What disappears is the illusion that engineering was ever about typing.</p><h3>A Line Worth Holding</h3><p>You do not need to claim AI will never reach something resembling AGI.</p><p>You only need to say this:</p><blockquote><em>There is no demonstrated path from today’s pattern-based systems to autonomous engineering judgment. Assuming otherwise is speculation, not planning.</em></blockquote><p>That position is not anti-AI, it is pro-engineering.</p><h3>Closing Thought</h3><p>AI does not threaten engineering.</p><p>It threatens the comforting belief that complex systems can be built by specification alone — whether the executor is a junior engineer treated like a cog or an AI treated like magic.</p><p>Engineering exists because that belief has always been false.</p><p>And no amount of generated code changes that.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5c4308005ecf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Vibe” Coding is not the Problem]]></title>
            <link>https://medium.com/@mwilson1962/vibe-coding-is-not-the-problem-e096c5ec610c?source=rss-88b27f9f5af4------2</link>
            <guid isPermaLink="false">https://medium.com/p/e096c5ec610c</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Mark Wilson]]></dc:creator>
            <pubDate>Fri, 02 Jan 2026 20:33:56 GMT</pubDate>
            <atom:updated>2026-01-02T20:33:56.546Z</atom:updated>
            <content:encoded><![CDATA[<p>Lately, LinkedIn has been full of noise about “vibe coding.” The term usually refers to developers leaning on AI to generate code they don’t fully understand, then shipping it anyway.</p><p>The concern is real. But those posts keep missing the real issue.</p><p>The problem isn’t that people are using AI. The problem is how they’re using it, and what they were doing before AI ever showed up.</p><p>AI doesn’t remove rigor from engineering. It amplifies whatever rigor you bring with you.</p><p>WHAT AI ACTUALLY CHANGES</p><p>AI is very good at producing code that looks plausible. It’s fast, fluent, and [over] confident.</p><p>What it is not good at is:<br> • knowing which constraints matter<br> • understanding unstated requirements<br> • recognizing architectural debt<br> • judging long-term consequences<br> • deciding what not to build</p><p>Those have always been core engineering responsibilities. But AI doesn’t take those away; it makes them central to your work.</p><p>When someone pastes AI-generated code into a system they don’t understand, the failure mode isn’t “AI wrote bad code.” The failure mode is outsourcing thinking.</p><p>That failure existed long before AI. AI just removes the camouflage.</p><p>HOW I ACTUALLY USE AI</p><p>I’ve been using AI extensively while writing a technical book on embedded systems and modern C++ design: B<a href="https://leanpub.com/buildingembeddedsystemsonlinuxamoderncapproach">uilding Embedded Systems on Linux: A Modern C++ Approach</a>.</p><p>What I don’t use it for:<br> • inventing architectures<br> • designing APIs<br> • making engineering trade-offs<br> • deciding what belongs in the system</p><p>What I do use it for:<br> • tightening explanations<br> • stress-testing arguments<br> • exposing weak spots in reasoning<br> • rewriting for clarity without changing intent<br> • acting as a tireless technical editor</p><p>In short, I use AI to amplify thinking I’ve already done, not to replace it.</p><p>If I can’t explain something clearly without AI, it doesn’t belong in the work.</p><p>THE REAL FAILURE MODE</p><p>Bad AI use isn’t really about laziness. It’s about skipping the hardest part of engineering: judgment.</p><p>If you don’t understand your system, AI will happily help you build the wrong one faster.</p><p>AI is excellent at filling in gaps. It is terrible at telling you which gaps matter.</p><p>BUT DOESN’T THIS ELIMINATE JUNIOR JOBS?</p><p>AI absolutely changes what entry-level work looks like. But that isn’t the same thing as eliminating junior engineers.</p><p>What is disappearing are roles built almost entirely on mechanical labor:<br> • translating specs into obvious code<br> • copying patterns without understanding<br> • producing volume without ownership</p><p>Those roles were fragile already. AI just made that visible.</p><p>A viable junior engineer today is someone who:<br> • can explain code they didn’t write<br> • can critique AI output<br> • can say “this is wrong” and justify it<br> • understands at least one system end to end<br> • treats AI as a tool, not an authority</p><p>That’s still junior. It’s just not passive.</p><p>THIS PATTERN IS FAMILIAR</p><p>Compilers didn’t eliminate programmers.<br>Higher-level languages didn’t eliminate programmers.<br>IDEs that generate chunks of code didn’t eliminate programmers.<br>Stack Overflow didn’t eliminate programmers.</p><p>Each shift reduced the value of rote work and increased the value of understanding. No one gets paid $100k to write HTML anymore!</p><p>AI follows the same pattern — just faster, and with less patience for confusion.</p><p>THE POINT EVERYONE KEEPS MISSING</p><p>The problem isn’t that people are “vibe coding.”</p><p>The problem is that many engineers never developed the discipline required before AI arrived.</p><p>AI didn’t break engineering. It exposed where engineering discipline was already thin.</p><p>AUTHOR’S NOTE</p><p>This article was written with the assistance of AI, used as an editor, critic, and clarity tool. The ideas, structure, arguments, and conclusions are mine. AI helped tighten language, stress-test explanations, and surface weak spots — and most of what it produced was rejected.</p><p>I could write this piece without AI. It would just take longer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e096c5ec610c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>