Mach's Principle Is Not About Inertia. It's About Everything.

J. Rogers, SE Ohio

When you remove every human unit standard from measurement, every physical quantity reduces to the same ratio against the universe. That ratio is what Mach was pointing at — and he didn't realize it was universal.

---

Physics has long known a set of equivalences. Each major field owns one link in a chain:

E/E_P = f·t_P = m/m_P = λ_P/λ = p/p_P = T/T_P = X

Relativists knew E ~ m. Quantum theorists knew E ~ f. Thermodynamicists knew E ~ T. Wave mechanicists knew f ~ 1/λ. Each community published their link and stayed inside their silo. Nobody applied transitivity across all of them simultaneously.

When you do apply transitivity — when you express every quantity in non-reduced Planck units and let the unit standards cancel — every quantity in the chain collapses to the same dimensionless ratio X. Not similar ratios. Not related ratios. The identical ratio.

---

What X actually is

The Planck Jacobian is the mathematical operation that performs this collapse. It cancels the human unit standards against the Planck unit chart — and crucially, both cancel completely. The human units disappear. But so do the Planck units.  Becue the Planck units are SI unit scaling inverted.  Neither survives the operation.

What remains is not a ratio against the Planck scale. The Planck scale is the solvent, not the residue — it cancels with the human unit standards and leaves nothing behind. No kilograms, no meters, no seconds, no Planck units. Just X: a pure, unitless ratio whose only reference is the entire universe itself.

The Planck Jacobian and the human unit standards annihilate each other. What survives is the raw relationship each quantity has to the whole — the universe as the sole remaining standard, carrying no units of any kind.

---

Mach saw it for inertia. It's true for everything.

Ernst Mach argued that inertia is not an intrinsic property of matter. It is a relationship — specifically, a relationship between a body and the rest of the universe. Mass doesn't resist acceleration because of something it contains. It resists acceleration because of its relational situation within the whole.

Mach was right. But he didn't realize he had found a universal principle, not a special one. Because when the Planck Jacobian cancels every unit standard simultaneously, every quantity — energy, frequency, temperature, momentum, length, mass — becomes the identical unitless ratio X against the same sole reference: the entire universe.

Mach's principle is not a special fact about inertia. It is a universal fact about measurement itself. Every measurable quantity is a relationship to the universe. Strip away every unit standard — human and Planck alike — and the only thing left is that relationship. Every axis collapses to the same X.

---

What this means for the constants

If every quantity is the same ratio X, then the equations connecting them — E=hf, E=mc², E=k_BT — are not deep discoveries about nature. They are tautologies. X = X, stated fifteen different ways for the fifteen pairwise combinations of six quantities.

The constants h, c, k_B, G are not profound facts about the universe. They are the conversion factors between the human unit systems that each silo developed independently — the fingerprints of our measurement conventions, not properties of nature. Einstein said as much about c²: mass and energy are the same thing measured two ways, and c² is unit scaling between them. The same is true of every constant in the chain.

Since 2019, the SI system has fixed h, c, e, and k_B by definition. If you change h, you have not discovered something new about nature. You have redefined the kilogram. The international metrology community enacted this conclusion without drawing its philosophical implications. The constants are conventions. Hume's guillotine applies: no amount of physics can prove that a mile has 5280 feet, and no amount of physics can give the constants values that are anything other than artifacts of our unit choices.

---

The natural ratios are what the universe looks like without us in the way

Strip away the kilogram, the meter, the second, the kelvin — every measurement standard humanity invented to navigate the world at human scales — and what remains is pure relation. The Planck Jacobian is the operation that performs this stripping. It cancels the human standards, cancels itself, and leaves only the universe relating to itself, with no intermediary.

This is what Mach was reaching for when he said inertia was relational. It is what Einstein was reaching for in his last thirty years when he searched for a unit-free description of the universe. None of them applied transitivity across every silo simultaneously. That step — seeing that every axis of measurement reduces to the identical X, that Mach's relational principle is universal and not special, that the Planck Jacobian cancels everything including itself leaving only the universe — is what the journal structure made impossible to publish and what self-publishing in March 2026 has now put on record.

The natural ratios are not a mathematical curiosity. They are what the universe looks like when you stop measuring it against a standard you invented and use the universe itself as your yardstick.

The First Book Is Live!!!

It is called "The Elephant In the Room" and it covers why we misunderstood constants for over 100 years.

I did a big push over the past few months and released the first of 3 books on this framework that this blog has been discussing for years now. 

The identifying number for the hardcover is ISBN-13979-8253948286.

The book is for sale here: https://www.amazon.com/dp/B0GVC7FRTV

There are three price points for the ebook, the paperback and the hardcover.  I am charging a fair price point for each version. 

This book covers one specific thing, how losing natural philosophy resulted in no foundational progress in physics for decades.  This was no one person's fault: it was how we set up the reward, grant and publishing structures that lead to this result.

Physics has a hundred-year-old mystery: why do the fundamental constants — c, h, G, k₂ — have the specific numerical values they have? The question has driven entire research programs. It has generated a literature of extraordinary sophistication. It has not been answered, because it cannot be answered inside the existing framework. It is the wrong kind of question.

The constants are not properties of the universe. They are properties of how we measure it. The value of G encodes the history of the French Revolutionary committee that defined the meter. The value of h encodes the definitions of the joule and the second. Change those definitions — as the 2019 SI committee did, by vote — and the numbers change. The physics does not change. Because the physics was never in the numbers.

This book identifies why that question felt profound, proves that it was malformed, and shows what the correctly formed questions look like.

The second book will cover what physics looks like with geometric ratios.  The third book will cover how we build conceptual axis, scale them, combine them into vector spaces to construct knowledge across all fields of science. How we construct knowledge has implications for achieving AGI. 

 

Measurement as Ratio: The Invariant Beyond Units and Constants

J. Rogers, SE Ohio

This paper is at: https://github.com/BuckRogers1965/Physics-Unit-Coordinate-System/tree/main/docs

---

Abstract

Measurement is the comparison of an object to a standard, yielding a dimensionless ratio. The subsequent attachment of a unit label is a human convention, not a discovery of an intrinsic property. The so‑called fundamental constants of physics—$c,h,G,k_B$—appear only because we have already fixed our unit system. When we divide a measured quantity by its corresponding Planck value (a combination of these constants expressed in the same units), both the arbitrary human unit and the Planck “scale” cancel completely, leaving a pure dimensionless number $X$ that depends on nothing but the object and the unified substrate. This number is the only physically meaningful invariant. The equality of $X$ across all conceptual axes (mass, length, time, temperature, etc.) is the algebraic expression of the universe’s unity. In this view, constants are not part of the invariant; they are merely the scaffolding we use to strip away our own conventions, and they vanish entirely when we do so.

---

1. What Measurement Is

Consider a balance. On one pan sits a standard mass stamped “1 kg”. On the other pan sits an apple. A rider is moved along a graduated bar until equilibrium; the rider’s position reads “0.2”. What has been discovered?

The physical fact is the equilibrium condition. That condition yields a dimensionless number: the ratio of the apple’s mass to the standard mass. Because the bar is linear, the reading means

$$\frac{m_{\mathrm{a}\mathrm{p}\mathrm{p}\mathrm{l}\mathrm{e}}}{m_{\mathrm{s}\mathrm{t}\mathrm{a}\mathrm{n}\mathrm{d}\mathrm{a}\mathrm{r}\mathrm{d}}}=0.2$$.

The apple does not possess the label “kg”. The label belongs to the standard. The act of measurement compares the apple to that standard, and the result is a pure number—a ratio.

This is not philosophy; it is the operational definition of measurement. Every measurement—a ruler, a clock, a thermometer—follows the same pattern: compare to a standard, obtain a dimensionless ratio, then by convention attach the standard’s unit to the object, multiplying the ratio by that unit. The unit label is transferred, not discovered.

2. The Arbitrariness of the Standard

The standard itself is arbitrary. The kilogram was once a platinum‑iridium cylinder; today it is defined by fixing Planck’s constant. Regardless, the choice of unit is a human convention. Any other choice (gram, pound, solar mass) would serve equally well; the numerical ratio $m_{\mathrm{\text{apple}}}/m_{\mathrm{\text{standard}}}$ would change accordingly, but the physical relation between apple and standard remains invariant.

When we write $m_{\mathrm{\text{apple}}}=0.2\mathrm{\text{kg}}$, we perform a conventional act: we take the pure ratio $0.2$ and attach the unit “kg” that belongs to the standard. We then speak as if the apple has a property “0.2 kg”. This reification obscures the relational nature of measurement.

3. The Unified Substrate and the Invariant $X$

The universe does not come pre‑divided into “mass”, “length”, “time”, etc. Those are conceptual axes we impose. Beneath them lies a single, coherent substrate of interacting phenomena. Every object participates in that substrate, and every interaction involves all aspects of reality simultaneously.

If the substrate is truly unified, then for any object there exists a single dimensionless number—call it $X$—that captures its relation to the whole. This number does not depend on any unit, any constant, or any axis. It is the raw, unit‑free coordinate of the object in the substrate. All measurements, regardless of which axis we use, are attempts to determine $X$.

4. Constants as Scaffolding: Canceling the Standard

The constants $c,h,G,k_B$ are not fundamental parameters that appear in $X$. Instead, they are conversion factors that we have defined within our unit system. Their numerical values are determined by that system. They serve as a bridge: given a measurement in kilograms, we can use the constants to completely eliminate the arbitrary standard.

Take the apple’s mass measured in kilograms: $m=0.2\mathrm{\text{kg}}$. The Planck mass is a combination of the constants:

$m_P=\sqrt{\frac{hc}{G}}$.

But note: $h$, $c$, and $G$ are themselves expressed in the same unit system (SI). Thus $m_P$ is simply a fixed number of kilograms: $m_P\approx 5.456\times {10}^{-8}\mathrm{\text{kg}}$.

Now form the ratio:

$\frac{m}{m_P}=\frac{0.2\mathrm{\text{kg}}}{m_P\mathrm{\text{kg}}}$.

The kilograms cancel. What remains is a pure number—the quotient of two numbers expressed in the same arbitrary unit. That number does not depend on the kilogram. It does not even depend on the constants, because the constants were used only to compute $m_P$ in kilograms, and that computation is exactly what cancels the unit.

The result is simply a number. It has no memory of the standard, no memory of the Planck mass, no memory of the constants. It is the invariant $X$.

We can write this directly as:

$X=\frac{m}{m_P}\mathrm{\text{(a pure number)}}$.

Because both numerator and denominator share the same unit, the unit vanishes. The constants that went into defining $m_P$ vanish as well—they were only a ladder, and once we climb it, we leave it behind.

5. The Same $X$ Across All Axes

Because the substrate is unified, the same invariant $X$ must be obtained regardless of which axis we use to measure the object. For length:

$X=\frac{l}{l_P}$,

where $l_P=\sqrt{Gh/c^3}$ (again expressed in meters). For frequency:

$X=\frac{f}{f_P}$,

with $f_P=\sqrt{c^5/(Gh)}$ (expressed in hertz). For temperature:

$X=\frac{T}{T_P}$,

with $T_P=\sqrt{c^{5}h/(G{k}_B^2)}$ (expressed in kelvin).

In each case, the Planck value is a fixed number in the corresponding human unit. Dividing by it cancels that unit, yielding the same dimensionless $X$. The equalities among these ratios are not accidental; they are the algebraic shadow of the substrate’s unity. They also explain why the constants take the values they do relative to our unit system: they are precisely the conversion factors that make all these normalized ratios equal to the same $X$.

6. Why the Constants Are Not Fundamental

A common misconception is that the constants are “fundamental parameters” that set the scale of nature. The present analysis shows the opposite: the constants are derived from the combination of our arbitrary unit system and the invariant $X$. If we chose different units, the numerical values of $c,h,G,k_B$ would change, but $X$ would remain the same. In fact, if we choose units where the constants become 1 (cancelling the unit stanards with Planck jacobians), then $X$ is simply the measured quantity itself—no constants remain. This reveals that the constants were never intrinsic; they were merely the conversion factors needed to express the invariant $X$ in terms of our chosen human units.

The reduced Planck constant $\hslash =h/(2\pi )$ does not appear in this story because the factor $2\pi$ is irrelevant to unit scaling. It is a mathematical convenience that just creates cleaner notation in formulas, not to the structure of measurement.

7. Implications

• Measurement reveals ratios, not properties. What we call “mass”, “length”, “time” are labels we attach to ratios.
• The only invariant is the dimensionless number $X$. It depends on the object and the substrate, not on any human convention.
• Constants are scaffolding. Their numerical values are artifacts of our unit system; they disappear entirely when we form the invariant $X$.
• Natural units are simply the choice to measure in units where the scaffolding becomes 1, making the invariants directly visible.
• Physical laws (e.g., $E=m{c}^2$, $E=hf$) are not independent; they are all expressions of the single relation $X=X$, projected onto different axes.

8. Conclusion

We began with a simple balance, an apple, and a standard. We saw that measurement yields only a dimensionless ratio, and that attaching a unit to the object is a convention. We then used the constants not as fundamental properties of nature, but as scaffolding that allows us to cancel our arbitrary units and reveal the true invariant $X$—a pure number that relates the object directly to the unified substrate. The same $X$ emerges from measurements of length, frequency, temperature, and every other axis, because the substrate is one.

The constants are the ladder; $X$ is the destination. When we finally look at the world without the ladder, we see only dimensionless numbers—and the unity that makes them equal across all axes.

---

Appendix A: Local Equivalences Without Global Transitivity

This appendix documents how standard physics already equates the major “silo” quantities pairwise—space with time, energy with mass, energy with frequency, energy with temperature, mass with inverse length, and so on—yet typically stops short of enforcing global transitivity across all silos. The result is a patchwork of local identifications that, if taken seriously and closed under transitivity, collapse into the single invariant $X$ described in the main text.

---

A.1 Local identifications inside each silo

1. Relativity: space $\leftrightarrow$ time $\leftrightarrow$ spacetime

   • Special relativity introduces Minkowski spacetime, where space and time are components of a single four‑vector.
     
   • In units where $c=1$, spatial distance and time interval share the same unit: a meter and the time it takes light to travel a meter are numerically identical.
     
   • Operationally, “one second” is defined by light travel over a fixed distance; conceptually, time and length are already unified in that frame.

2. Relativistic energy: energy $\leftrightarrow$ mass

   • The relation $E=m{c}^2$ makes energy and mass proportional.
     
   • In units where $c=1$, mass and energy carry the same dimension; a particle can be labeled interchangeably by its “mass” or its “rest energy.”

3. Quantum mechanics: energy $\leftrightarrow$ frequency, time $\leftrightarrow$ energy

   • The Planck relation $E=hf$ identifies energy with frequency; choosing units with $h=1$ makes them numerically identical.
     
   • The energy–time uncertainty relation ties energy scales to time scales, reinforcing the link between temporal structure and energetic structure.

4. Statistical mechanics: energy $\leftrightarrow$ temperature

   • The relation $E\sim k_{B}T$ identifies characteristic energies with temperatures.
     
   • In units where $k_B=1$, “temperature” is literally just energy per degree of freedom; the numerical distinction disappears.

5. Quantum field theory: mass $\leftrightarrow$ inverse length $\leftrightarrow$ inverse time

   • A particle’s Compton wavelength satisfies ${\lambda }_C\sim 1/m$ (with $\hslash =c=1$), so mass and inverse length are interchangeable.
     
   • Frequencies and time scales also enter via dispersion relations; in natural units, mass, energy, inverse length, and inverse time all share the same dimension.

Within each theoretical silo, then:

• Relativity collapses space and time.
  
• Relativity plus mass–energy equivalence collapses mass and energy.
  
• Quantum theory collapses energy and frequency, and ties energy to time scales.
  
• Statistical mechanics collapses energy and temperature.
  
• Quantum field theory collapses mass, inverse length, inverse time, and energy.

Each community implicitly says, “in the right units, these two are the same thing,” but usually only within its own conceptual neighborhood.

---

A.2 The transitivity that is not enforced

Taken together, these equivalences form a connected graph:

• Nodes: $\{\mathrm{\text{space}},\mathrm{\text{time}},\mathrm{\text{mass}},\mathrm{\text{energy}},\mathrm{\text{frequency}},\mathrm{\text{temperature}},\mathrm{\text{inverse length}},\dots \}$.
  
• Edges: proportionalities such as $c$, $h$, $k_B$, and $\hslash$ that become 1 in suitable units.

By ordinary reasoning:

• If space $\leftrightarrow$ time (via $c$), and time $\leftrightarrow$ energy scales (via uncertainty relations), and energy $\leftrightarrow$ mass (via $E=m{c}^2$), and mass $\leftrightarrow$ inverse length (via Compton wavelength), then space is connected to inverse length and mass and temperature and frequency through a chain of identifications.
  
• Once all the conversion factors are set to 1 (Planck or natural units), every edge becomes an equality of numerical variables.

However, in practice:

• Each field uses the equivalence it needs and then stops.
  
• Relativists talk about spacetime, but do not typically say “length is just inverse temperature” in the same breath, even though the chain of known equivalences leads there.
  
• Stat mech texts treat $k_{B}T$ as an “energy scale” but rarely connect that directly to, say, an inverse length scale via the full transitive closure of all constants.
  
• QFT works happily with mass $\sim$ inverse length $\sim$ inverse time, but still labels these as different “kinds” of quantity.

The result is a locally unified, globally segregated picture: each silo is internally consistent and uses some subset of equivalences, yet the discipline as a whole does not promote the full connected graph to a single equivalence class under transitivity.

---

A.3 From local equivalences to a single invariant $X$

The main text of the paper takes the next step:

1. Start with the network of identifications already accepted in each silo.
   
2. Strip away human units by normalizing to Planck (or equivalent natural) scales.
   
3. Take transitivity seriously across the entire network.

Under this view:

• Once $c=h=G=k_B=1$, all the proportionality constants become identity maps.
  
• Every “axis”—mass, length, time, temperature, frequency, etc.—is just a different coordinate chart on a single substrate.
  
• For a given object, the normalized quantities $m/m_P$, $l/l_P$, $t/t_P$, $T/T_P$, $f/f_P$, and so on are not merely dimensionless; they are equal to the same invariant number $X$, because they are all descriptions of the same underlying relation to the unified substrate.

In other words, the discipline has already built the ladder:

• It has identified all the rungs pairwise (inside each silo) and even adopted unit systems where the constants become 1.
  
• What it has not done is declare the ladder collapsed: enforce global transitivity and announce that there is only one invariant coordinate left after all equivalences and normalizations are applied.

---

A.4 Why the global closure is typically avoided

This appendix does not claim that global transitivity is logically impossible within current physics; rather, it notes that it is not standard practice to enforce it. Reasons include:

• Conceptual convenience: Keeping “mass,” “length,” and “temperature” as distinct labels is pedagogically and practically useful, even if they become numerically equivalent in certain units.
  
• Multiple dimensionless parameters: The Standard Model and cosmology appear to involve many independent dimensionless couplings and ratios; this encourages a view with many invariants instead of a single $X$.
  
• Disciplinary silos: Each subfield optimizes its own language and rarely insists on a fully unified ontology across all others.

The paper’s proposal is precisely to close the loop: to recognize that the community has already accepted enough pairwise identifications that, when taken together and normalized by Planck jacobians that cancel the unit standards, they naturally define a single dimensionless invariant $X$ that survives the collapse of all silos.

---

References

1. Annenberg Learner – “Learning Math: Measurement – Part B: The Role of Ratio (Fundamentals of Measurement)”. learner This resource explicitly frames measurement as comparing an unknown to a standard and emphasizes that the result is a ratio, not an intrinsic property, which underpins your Section 1 claim that measurement yields a dimensionless number before any unit label is attached.

2. “Measurement in Science,” Stanford Encyclopedia of Philosophy (SEP). plato.stanford The SEP article provides a rigorous philosophical and operational account of measurement as the assignment of numbers via comparison procedures and standardized instruments, supporting your treatment of units and standards as conventions layered on top of a more primitive comparison process.

3. “Measurement,” Wikipedia. en.wikipedia This overview describes measurement as the process of associating numbers with physical quantities according to rules and standards, reinforcing your argument that the act itself is a structured comparison to a conventional unit rather than the discovery of a built‑in label like “kg” in the object.

4. “Dimensionless Physical Constant,” Wikipedia. en.wikipedia This entry defines dimensionless constants as pure numbers whose values are independent of any unit system, which dovetails with your invariant $X$ as a unit‑free quantity and supports your claim that only such dimensionless combinations are truly universal.

5. J.‑P. Uzan, “Dimensionless constants and cosmological measurements,” arXiv:1304.0577. arxiv Uzan argues that only dimensionless combinations of constants are operationally meaningful in cosmology and fundamental physics, directly resonating with your thesis that $c,h,G,k_B$ are scaffolding for constructing invariant, dimensionless ratios rather than themselves being part of the invariant.

6. “Planck Units,” Wikipedia. en.wikipedia This article defines Planck units by setting $c,\hslash ,G,k_B$ to 1 and shows how quantities like the Planck mass, length, and temperature arise from these constants, supporting your construction of $m_P,l_P,T_P$ as unit‑dependent scales used only to cancel human units and expose the pure number $m/m_P$, $l/l_P$, etc.

7. “Planck units,” TCS Wiki. tcs.nju.edu The TCS Wiki summary highlights that Planck units arise from combining constants associated with relativity, quantum theory, gravitation, and thermodynamics, which aligns with your view that these constants are conversion bridges between conceptual axes rather than independent “fundamental properties” appearing in $X$.

8. “UNIT 1: Philosophy of Measurement – Calibration,” engineering metrology notes. scribd These metrology notes stress that a measurement result is a number representing the ratio of the quantity to a chosen unit, and they discuss standards and calibration as conventional but necessary structures, lending technical support to your Sections 2 and 4, where the kilogram and other standards are treated as arbitrary scaffolding used to reveal the underlying dimensionless invariant.

Adding CC to Vizio Control

J. Rogers, SE Ohio

Below are the exact, minimal changes needed across the four files to add the Closed Captions (CC) button. It places the button in the empty top-right space of the D-Pad cluster in both the Pygame GUI and the Web GUI, without moving any existing buttons.

1. vizio_control.py (Core Logic & CLI)

Step A: Add the CC command to the TV class.
Find the key_info method (around line 326) and add the cc method right below it:

    def key_info(self):
        """Press Info"""
        return self.send_key(4, 6)
    
    # --- ADD THIS NEW METHOD ---
    def cc(self):
        """Toggle Closed Captions"""
        return self.send_key(13, 0)

Step B: Add the command to the CLI handler.
Find the elif command == "info": block in the main() function (around line 630) and add the CC block below it:

        elif command == "info":
        success = tv.key_info()
        if success:
            print("✓ Info")
        sys.exit(0 if success else 1)

    # --- ADD THIS BLOCK ---
    elif command == "cc":
        success = tv.cc()
        if success:
            print("✓ CC")
        sys.exit(0 if success else 1)

---

2. vizio_flask.py (Web Server Backend)

Add the command to the Flask API router.
Find the elif command == "info": line in the execute_command function (around line 52) and add the CC line below it:

        elif command == "info":
            success = tv.key_info()
            
        # --- ADD THIS ---
        elif command == "cc":
            success = tv.cc()

---

3. vizio_gui.py (Desktop App GUI)

Step A: Draw the button in the D-Pad cluster.
Find the D-Pad section in create_buttons() (around line 114). Define the cc_btn and update the self.buttons.extend list to include it:

                # OK (center)

        ok_btn = Button(dpad_center_x - small_btn//2, dpad_center_y - small_btn//2+30, 
                       small_btn, small_btn, "OK", lambda: self.execute_command("ok"), ACCENT_COLOR)
        
        # --- ADD THIS BUTTON ---
        cc_btn = Button(dpad_center_x + small_btn + 20, dpad_center_y - small_btn, 
                       50, 40, "CC", lambda: self.execute_command("cc"))
        
        # --- UPDATE THIS LINE TO INCLUDE cc_btn ---
        self.buttons.extend([up_btn, down_btn, left_btn, right_btn, ok_btn, cc_btn])

Step B: Handle the command click.
Find the elif command == "info": line in the execute_command method (around line 177) and add the CC line below it:

        elif command == "info":
            success = self.tv.key_info()
                
        # --- ADD THIS ---
        elif command == "cc":
            success = self.tv.cc()

---

4. templates/remote.html (Web App GUI)

Step A: Add the CSS grid coordinates.
Find the .dpad-down CSS rule in the <style> section (around line 96) and add the .dpad-cc rule directly below it. (This safely uses the empty top-right grid square):

        .dpad-up { grid-column: 2; grid-row: 1; }
        .dpad-left { grid-column: 1; grid-row: 2; }
        .dpad-ok { grid-column: 2; grid-row: 2; }
        .dpad-right { grid-column: 3; grid-row: 2; }
        .dpad-down { grid-column: 2; grid-row: 3; }
        
        /* --- ADD THIS LINE --- */
        .dpad-cc { grid-column: 3; grid-row: 1; font-size: 16px; }

Step B: Add the HTML button.
Find the <div class="dpad-container"> block (around line 186) and append the new button inside the container:

        <!-- D-Pad Navigation -->
        <div class="dpad-container">
            <button class="button dpad-button dpad-up" onclick="sendCommand('up')">▲</button>
            <button class="button dpad-button dpad-left" onclick="sendCommand('left')">◄</button>
            <button class="button dpad-button dpad-ok accent-button" onclick="sendCommand('ok')">OK</button>
            <button class="button dpad-button dpad-right" onclick="sendCommand('right')">►</button>
            <button class="button dpad-button dpad-down" onclick="sendCommand('down')">▼</button>
            
            <!-- --- ADD THIS LINE --- -->
            <button class="button dpad-button dpad-cc" onclick="sendCommand('cc')">CC</button>
        </div>

Since Vizio doesn't publish an official list, you have to use these community-maintained sources to find the codes, like the following:

https://github.com/heathbar/vizio-smart-cast/blob/master/test/test-control.js

The Architect and the Apprentice: A Practical Model for AI-Assisted Software Development

 J. Rogers — SE Ohio

---

Abstract

The emergence of large language model assistants capable of generating functional code has created a misleading narrative: that AI can build software. This paper argues the opposite — that AI cannot build software, but that an experienced architect working with an AI assistant can build software dramatically faster than working alone. The distinction matters. The difference between these two framings is the difference between a useful tool and a source of expensive mistakes. This paper describes a working collaboration model developed during the construction of a complete IoT firmware platform for the Raspberry Pi Pico W, built in approximately four days, and examines what that collaboration reveals about the practical role of AI in professional software development.

---

1. The Myth of the Autonomous AI Developer

The marketing narrative around AI coding assistants suggests that they can build software autonomously — that a developer can describe what they want in plain English and receive working, production-quality code. This is false, and believing it leads to predictable failures.

AI assistants are pattern completion engines. They are extraordinarily good at implementing things that have been clearly specified and that resemble things they have seen before. They are incapable of understanding what a system should be, why it should be that way, and what tradeoffs matter. They have no judgment about architecture. They have no stake in the outcome. Left to their own tendencies, they will produce code that compiles, passes obvious tests, and fails in production in ways that are difficult to diagnose because the failure is architectural rather than syntactic.

More dangerously, AI assistants are confidently wrong. They do not know the boundary between what they know and what they are fabricating. An AI asked to implement NTP on a microcontroller will produce code that looks correct, cites plausible-sounding APIs, and may not compile. When corrected, it will produce a new version with equal confidence. The experienced developer catches this immediately. The inexperienced developer does not.

---

2. What Experience Actually Provides

The BluePrint IoT framework was built in approximately four days of collaboration between a human architect and an AI assistant. The framework implements a dual-core asymmetric multiprocessing architecture, a lock-free inter-core communication system using hardware FIFO, a zero-allocation chunked web server, a declarative three-table UI engine with boot-time compilation, multi-page routing, eight widget types, eight container types, a captive portal provisioning system, mDNS discovery, and a Home Assistant MQTT auto-discovery bridge — leaving 62% of SRAM free on a $6 microcontroller.

None of the architectural decisions in that list came from the AI. Every significant design choice was made by the human architect:

• The decision to use Asymmetric Multiprocessing and assign Core 1 exclusively to hardware and Core 0 exclusively to networking
• The decision to use the RP2040 hardware FIFO for inter-core communication rather than a shared memory mutex
• The decision to implement state coalescing — absorbing rapid successive updates and transmitting only the final value — to prevent FIFO congestion
• The decision to use zero-allocation chunked streaming to prevent heap fragmentation over long runtimes
• The decision to completely separate the registry (the Model) from the layout table (the View) — not because it was the obvious choice, but because it was the architecturally correct choice that no existing framework in this space had made
• The decision to perform boot-time string resolution — converting all string-based ID references to numeric indices in a single forward pass at startup — so that runtime rendering involves only O(1) array operations

The AI implemented these decisions competently once they were specified. It also, on multiple occasions, deviated from them when given insufficient direction. When asked to "add debug prints back," it rewrote both files from scratch in its own style, stripping commented-out code, changing brace formatting, altering function signatures, and removing the handleManifest_orig() function entirely. When asked to "add the layout system," it invented a second data structure that merged the registry with the layout information — precisely the architectural mistake the human architect had already identified and rejected. In both cases the mistake was caught immediately and corrected, because the architect knew what the code was supposed to be.

This is the critical insight: the value of experience in AI-assisted development is not in knowing how to implement things — the AI can implement things. The value is in knowing when the AI has implemented the wrong thing.

---

3. Where AI Provides Genuine Leverage

Within the bounds set by an experienced architect, an AI assistant provides extraordinary leverage in specific areas.

3.1 Cross-Protocol Implementation

The BluePrint framework touches C++, HTML, CSS, JavaScript, Python, SVG, POSIX timezone strings, MQTT, mDNS, lwIP, the RP2040 hardware FIFO protocol, Arduino's WebServer chunked streaming API, and JSON. For a single human developer, switching between these domains has a significant cognitive cost — remembering the exact syntax for SVG stroke-dasharray, the correct lwIP SNTP callback signature, the Python paho.mqtt API, the mDNS service record format. Each context switch costs time and introduces the risk of small mistakes.

For an AI assistant, there is no context switch cost. The same session that generates correct C++ for a hardware FIFO message packing function can immediately generate the Python bridge that reads those messages over REST and publishes them to MQTT, and then generate the CSS that styles the SVG gauge that displays the result. The developer describes what is needed; the AI produces the implementation in whatever language or protocol is required.

This is where the leverage is most dramatic. A developer working alone would spend significant time on reference documentation for each domain. The AI has already internalized that documentation and applies it without lookup overhead.

3.2 Boilerplate Elimination

A large fraction of software development time is spent on code that is correct but uninteresting — error handling, serialization, HTML generation, configuration management, logging. This code must be written carefully but requires no creative judgment. It is precisely the code that AI generates most reliably.

In the BluePrint framework, the entire HTML/CSS/JavaScript rendering system — hundreds of lines of carefully structured string output across a dozen widget renderers — was generated by the AI under direction. The architect specified what each widget should look like and how it should behave. The AI produced the implementation. The architect reviewed and corrected where needed. The total time spent on the web rendering layer was a fraction of what it would have been writing it manually.

3.3 Documentation

Documentation is the area where AI assistance provides the most unambiguous value. Writing accurate technical documentation requires understanding the system, knowing all the edge cases, and being able to express them clearly — but it does not require the architectural judgment that makes good software good. An AI given access to the actual source code can produce accurate, well-organized documentation faster than any human.

During the BluePrint development session, the AI produced a complete configuration manual, a layout table reference manual, two implementation guides, a blog post, a README rewrite, and an NTP implementation plan — all in the same session that produced the code they document. Every document was based on the actual implemented code, not on what the code was intended to be. This is documentation that would realistically take days to write manually and would typically not be written at all until long after the code was considered "done."

3.4 Exploration and Validation

An experienced developer with a clear architectural vision can use an AI assistant to rapidly prototype alternatives. "What if we used pathLength normalization for the SVG dial instead of calculating arc length?" The AI implements it, it works, it's correct. The developer would have found the right approach eventually, but the AI found it in seconds. The human provides the question; the AI explores the solution space.

---

4. The Failure Modes

Understanding where AI assistance fails is as important as understanding where it succeeds.

4.1 Scope Creep

The most consistent failure mode observed during BluePrint development was scope creep — the AI making changes beyond what was requested. Asked to "add debug prints," it rewrote files. Asked to "add the layout system," it changed the registry design. Asked to "fix the dial," it reversed the arc path rather than investigating the underlying math error.

The root cause is that AI assistants optimize for producing something that looks correct rather than something that is minimal. When regenerating a file from scratch, they write it in their own preferred style. When fixing a bug, they may restructure surrounding code that was not part of the bug. This is not malicious — it is a consequence of how these models generate text, which is by predicting what a complete, well-formed response looks like rather than what the minimum necessary change is.

The mitigation is procedural: always start from the actual existing file, always use surgical edits (str_replace rather than file regeneration), and always verify with a diff that only the intended lines changed. An experienced developer catches scope creep in the diff immediately. An inexperienced developer may not notice that comments were deleted, debug functions were removed, and variable names were changed — until something breaks in production.

4.2 Confident Fabrication

AI assistants fabricate plausible-sounding APIs that do not exist. During BluePrint development this manifested as an sntp.h include path that the compiler could not find. The AI had seen SNTP callback code in its training data, constructed a plausible include path, and presented it with complete confidence. The error was caught at compile time — a relatively benign failure mode. Fabricated logic errors that compile successfully are harder to catch.

The mitigation is verification: when an AI cites a specific API, function signature, or library feature that is unfamiliar, verify it against documentation before using it. The AI's confidence is not a signal of correctness.

4.3 Architectural Drift

Without continuous correction, AI-generated code drifts from the established architecture. This is the most dangerous failure mode because it is the hardest to catch. A function that should use the registry's numeric index silently uses a string lookup instead. A widget renderer that should stream in chunks builds a full String in RAM. A handler that should be stateless quietly accumulates state in a global variable.

Each of these is a small local decision that looks reasonable in isolation and violates the architectural constraints that make the system work at scale. The experienced architect catches them because they know the constraints and recognize when they are being violated. The inexperienced developer accepts the output because it compiles and produces the right answer in testing.

---

5. A Working Collaboration Model

Based on the BluePrint development experience, the following model describes effective AI-assisted development:

The architect owns the design. Every significant architectural decision — what the system is, why it is structured the way it is, what constraints must be maintained — belongs to the human. These decisions are not negotiable with the AI. The AI does not get to refactor the registry because it thinks a different structure would be cleaner.

The AI owns the implementation details. Within the bounds set by the architect, the AI implements. It writes the C++, the JavaScript, the Python, the CSS, the documentation. It handles the cross-protocol mechanics that would require constant reference lookup for a single developer. It produces the boilerplate that is correct but uninteresting.

The architect reviews everything. Every file the AI produces gets diffed against the previous version. Every change that was not requested is a failure. Every new dependency, every changed variable name, every deleted comment is a potential problem. The review is not optional.

Direction is explicit and minimal. "Add debug prints" is not a sufficient instruction — it will produce a rewrite. "Add a debug print to each of these three functions, showing these specific values, do not change anything else" is a sufficient instruction. The more explicit the constraint, the less scope the AI has to drift.

Corrections are immediate and specific. When the AI makes a mistake, the correction names the specific mistake and the specific expected behavior. General corrections ("don't change things you weren't asked to change") produce temporary compliance. Specific corrections ("you changed the CONTAINER macro signature — revert it to exactly the original") produce accurate fixes.

---

6. The Irreducible Human Role

There is a floor below which AI assistance cannot substitute for human judgment in software development, and that floor is set by the complexity and novelty of the problem.

For trivial problems — connecting to a database, parsing a JSON file, formatting a date — the AI can operate nearly autonomously because the solution space is well-defined and the correctness criteria are obvious. For non-trivial problems, the value of AI decreases monotonically as the problem becomes more novel, more constrained, or more consequential.

The BluePrint framework was a novel problem — no existing framework had solved it this way, on this hardware, with these constraints. The architectural decisions were not derivable from patterns in the AI's training data because the pattern did not exist yet. A developer with less experience in embedded systems, concurrent programming, web server architecture, and IoT protocols would not have been able to specify the correct architecture, would not have caught the AI's deviations from it, and would not have known when the fabricated API was wrong.

The AI made the implementation fast. The human made the implementation correct.

This is the working model: AI as a force multiplier for experienced developers, not a replacement for them. The multiplier is real — four days to build a complete IoT platform that would realistically take weeks or months working alone is a genuine and significant acceleration. But the multiplier only applies to the experienced developer who can set the direction, maintain the constraints, and catch the failures.

For developers without that experience, AI assistance is more likely to produce confidently wrong code faster than correct code slowly. The speed of generation is not matched by any corresponding increase in the speed of verification — and verification, ultimately, is the bottleneck.

---

7. Conclusion

The practical model for AI-assisted software development is not human-as-prompter and AI-as-developer. It is human-as-architect and AI-as-highly-capable-but-undisciplined-implementer. The human provides judgment, constraints, architectural vision, and continuous review. The AI provides implementation speed, cross-domain fluency, and elimination of lookup overhead.

The experienced developer who understands this model can build things that would not have been possible in the same timeframe working alone. The developer who believes the AI can build software independently will produce systems that work until they don't, and will have difficulty understanding why.

The value of experience has not decreased in the age of AI coding assistants. It has increased — because the primary job of the experienced developer is no longer to type code, it is to know what code should be typed and to recognize when the wrong code has been typed instead. That judgment is not in the model. It never will be.

---

Developed during the construction of the BluePrint IoT Framework for the Raspberry Pi Pico W. Source: https://github.com/BuckRogers1965/Pico-IoT-Replacement