<?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 Daniel Hodvogner on Medium]]></title>
        <description><![CDATA[Stories by Daniel Hodvogner on Medium]]></description>
        <link>https://medium.com/@dhodvogner?source=rss-f610ce5a90f2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Ukg1hJe0pjejtg3T.</url>
            <title>Stories by Daniel Hodvogner on Medium</title>
            <link>https://medium.com/@dhodvogner?source=rss-f610ce5a90f2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 19:27:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dhodvogner/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[Why Autonomous Software Factories Were Always Coming]]></title>
            <link>https://medium.com/@dhodvogner/why-autonomous-software-factories-were-always-coming-18bc91364b6d?source=rss-f610ce5a90f2------2</link>
            <guid isPermaLink="false">https://medium.com/p/18bc91364b6d</guid>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[future]]></category>
            <category><![CDATA[innovation]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Daniel Hodvogner]]></dc:creator>
            <pubDate>Wed, 14 Oct 2026 11:14:15 GMT</pubDate>
            <atom:updated>2026-10-14T11:14:15.620Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*42X8swDHeFNnujUS0IEHGA.jpeg" /><figcaption><em>Illustration generated with AI (Nano Banana 2.1 via fal.ai)</em></figcaption></figure><p>If you’ve been a software developer for a while, you know the feeling. You finally upgrade the framework, and a week later there’s a new major version. You patch the CVE, and three more show up in your transitive dependencies. The ticket says “done,” but nothing is ever really done.</p><p><em>A note on how this was made: the theory and the questions are mine, from years of feelings and hands on experience working in IT. I used Claude to help fact-check the history, find sources, and tighten the writing. Which, given the topic, felt only fair.</em></p><p>For years I felt stuck in this “endless loop” every day, without being able to explain why. Then it clicked: the hamster wheel we’re spinning in exists for a reason. It’s part of a trend that’s been running for about 60 years, and it’s heading somewhere very specific.</p><p>Here’s the short version of my argument. Every era of software development removed one bottleneck, and every time, software started changing faster. We’ve now removed almost all of them. The next one standing is us: human attention. The <strong>autonomous software factory</strong>, a swarm of AI agents that writes, tests, and ships code without a human reading it, is what happens when that current bottleneck goes too.</p><p>That’s not science fiction. And it’s not another “AI will take our jobs” doomsday scenario. It’s just a simple realization I had when I zoomed out and looked at the major trends in software development and distribution over the past decades. As you’ll see, some teams are already running software factories. But first, let’s walk the timeline.</p><h3>Era 1 (1950s–1960s): When software was physical</h3><p>In the early days, software literally had weight. Programs lived on punched cards and paper tape. Fun fact: the word “patch” comes straight from this world. It goes back at least to the Harvard Mark I in 1944, which read its programs from paper tape. A small fix meant gluing a patch over the wrong holes and punching new ones, a bigger one meant cutting out a section and splicing in a new piece. Vendors later mailed fixes on tape or cards for customers to splice in themselves.</p><p>Change was slow because every change touched a physical object. You couldn’t push a fix to a thousand machines. Someone had to carry the new deck over. By hand!</p><p>Software also wasn’t really a product yet. It mostly came bundled with the hardware, and users shared code with each other. IBM’s mainframe user group SHARE, founded in 1955, was basically open source before open source had a name. It kept a shared library of members’ fixes and add-ons, and in 1959 it even released its own operating system. Software only became a separate thing you sell when IBM “unbundled” it from hardware in 1969.</p><p>To be fair to history: fixes did exist. IBM shipped official fixes for its mainframe systems. But they moved at the speed of mail, tapes, and on-site engineers. Once a system was installed and working, you mostly left it alone.</p><p><strong>Bottleneck: physical media.</strong></p><h3>Era 2 (1970s–1980s): Versions in a box</h3><p>Then came the personal computer, and with it, software as a retail product. VisiCalc in 1979, Lotus 1–2–3 in 1983, WordPerfect, MS-DOS. You bought a box with floppy disks and a thick manual in a store.</p><p>This is where version numbers really became a thing. Version 2 wasn’t a patch to version 1. It was a new box, sold again, often for an upgrade fee. Each release was still treated as one finished product.</p><p>And if version 1 had a bug? You lived with it, used a workaround from the manual or a magazine, or waited a year or two for the next version. Getting fixed bits to millions of home users simply had no cheap channel.</p><p><strong>Bottleneck: distribution. Every change meant manufacturing and shipping physical copies.</strong></p><h3>Era 3 (1990s–2000s): Patching goes mainstream</h3><p>The 90s cracked the distribution problem, first slowly, then all at once.</p><p>At first, patches traveled through bulletin board systems, FTP servers, and (my favorite) the CDs glued to the covers of PC magazines. I still have an entire box of them somewhere. If you were a gamer like me back then, you remember hunting for that one patch that fixed a crash or brought some quality-of-life upgrades.</p><p>Then the vendors built their own pipes:</p><ul><li><strong>1998:</strong> Windows Update launches with Windows 98. The operating system can now fetch its own fixes.</li><li><strong>2003:</strong> Microsoft formalizes “Patch Tuesday,” a monthly security release. Patching is now a calendar event.</li><li><strong>2003:</strong> Valve launches Steam, and games start updating themselves in the background.</li><li><strong>2005:</strong> Tim O’Reilly describes the “perpetual beta” in his famous Web 2.0 essay: web software is never shipped, only continuously improved.</li><li><strong>2009:</strong> Gmail finally drops its “beta” label, after five years and a massive user base.</li></ul><p>That Gmail detail says it all. One of the most used products on the internet was officially “unfinished” for five years, and nobody cared.</p><p><strong>Bottleneck removed: distribution.<br>New bottleneck: integration and release, still largely manual.</strong></p><h3>Era 4 (2000s–2010s): Package managers and continuous delivery</h3><p>I used to think package management was a 2010s thing. Only when I started working on this article did I learn that it’s actually older than that. Perl’s CPAN went live in 1995, and Debian’s APT arrived in 1998. Then came PyPI (2003), Maven and RubyGems (2004), npm (2010), and Rust’s Cargo (2015). What the 2010s did was make them <em>the</em> way everyone builds software.</p><p>At the same time, the way we ship changed completely:</p><ul><li><strong>2001:</strong> The Agile Manifesto. Small iterations instead of big-bang releases.</li><li><strong>2009:</strong> At the Velocity conference, Flickr engineers give the legendary talk “10+ Deploys Per Day.” People in the audience thought they were crazy.</li><li><strong>2010:</strong> Jez Humble and David Farley publish <em>Continuous Delivery</em>. Google’s Chrome moves to a six-week release cycle. Firefox follows in 2011.</li><li><strong>2011:</strong> Amazon reports deploying to production every 11.6 seconds on average. Eric Ries publishes <em>The Lean Startup</em>, and “ship it unfinished, learn, iterate” becomes official startup doctrine.</li></ul><p>So software became Lego: thin layers of your own code on top of hundreds of other people’s packages. Building got way faster. But it came with a hidden bill, the upkeep.</p><p>Two moments made that bill visible:</p><ul><li><strong>March 2016, left-pad:</strong> a developer unpublished an 11-line npm package. It broke the builds of thousands of projects, including big names like React and Babel. <strong><em>Only eleven lines of code!</em></strong></li><li><strong>December 2021, Log4Shell:</strong> a critical vulnerability was found in Log4j, a logging library buried deep in a massive number of Java systems. Teams spent weeks just figuring out <em>where</em> they were even using it.</li></ul><p><strong>Bottleneck removed: integration and release.<br>New bottleneck: keeping up with everything you depend on.</strong></p><h3>Era 5 (2015–today): Software that is never finished</h3><p>Today the two-week sprint feels normal, but it’s actually the slow lane. Google-backed DORA research (its 2019 report alone surveyed about 31,000 professionals) defines its elite performers as teams that deploy on demand, multiple times per day. Firefox moved to four-week releases at the end of 2019, and Chrome followed in 2021, tightening its cycle from six weeks to four. Microsoft pitched Windows 10 in 2015 as “Windows as a service”: not a version you buy, but a stream of updates.</p><p>Look at almost any modern product and you’ll see the same pattern:</p><ul><li>It ships unfinished, on purpose, and gets features added continuously.</li><li>There’s no “stable version” anymore, just whatever build is live today.</li><li>Even if you add zero features, you still have to keep upgrading frameworks, runtimes, and dependencies, or the thing slowly rots.</li></ul><p>That last point isn’t just developer whining. Starting in 1974, computer scientists Meir Lehman and Laszlo Belady studied how large programs like IBM’s OS/360 evolved, and formulated what are now called <strong>Lehman’s laws of software evolution</strong>. Two of them are basically this article in one sentence each.</p><blockquote><em>A system that’s actually used must keep changing, or it becomes progressively less useful. And as it changes, its complexity grows, unless someone puts in work to reduce it.</em></blockquote><p>Lehman saw this coming 50 years ago. We just made it faster.</p><p><strong>Bottleneck now: human attention. Someone still has to write, review, and understand every change.</strong></p><h3>The pattern: every era removes one bottleneck</h3><p>Zoom out and the timeline stops looking like a random series of inventions. It’s one bottleneck after another getting removed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sWvo-7GwbGDNZ8uQVmLT-g.jpeg" /><figcaption><em>Illustration generated with AI (Nano Banana 2.1 via fal.ai)</em></figcaption></figure><ul><li><strong>1950s–60s:</strong> held back by physical media. Removed by disks, tapes and terminals. Releases: rarely, if ever.</li><li><strong>1970s–80s:</strong> held back by physical distribution. Removed by the internet and auto-updaters. Releases: every year or two.</li><li><strong>1990s–2000s:</strong> held back by manual integration and release. Removed by package managers and CI/CD. Releases: months, then weeks.</li><li><strong>2010s–today:</strong> held back by the upkeep of the dependency stack. Eased by automation and DevOps. Releases: weeks, then days, then hours.</li><li><strong>Next:</strong> held back by human attention. Removed by autonomous software factories. Releases: continuously.</li></ul><p>One honest correction to my own first draft: I used to believe this growth was “exponential”, leading to “infinite” software.</p><p>But actually, it’s not a smooth curve! It’s more like a staircase. Each time a bottleneck goes, the pace of change jumps and then settles until it hits the next wall.</p><p>The interesting part is what <em>drives</em> the climb. It’s not that we want faster releases for their own sake. It’s that the demand for change (bugs, security, features, platform shifts, dependency updates) was always bigger than our capacity to deliver it. Every time capacity went up, the backlog grew with it.</p><p>And right now, the only thing standing between us and finally clearing that endless pit of a backlog is our own capacity to read and review code.</p><h3>The autonomous software factory is already here</h3><p>When I first sketched this idea, I thought it was a prediction about the future. But as always in the software business, if you’ve thought of it, you can be 100% sure someone is already working on it! There are even teams that have already built it!</p><p>In January 2026, Glowforge CEO Dan Shapiro proposed five levels of AI-assisted programming, modeled on the levels of self-driving cars. They run from “spicy autocomplete” up to the <strong>dark factory</strong>: a process that’s basically a black box turning specs into software. The name comes from manufacturing, from robot-run factories that can operate with the lights off because no humans are on the floor.</p><p>A few weeks later, StrongDM’s AI team went public with their version, which they simply call a Software Factory. Their charter has two rules: code must not be written by humans, and code must not be reviewed by humans. Their CTO’s rule of thumb is that if you’re not spending at least $1,000 a day on tokens per engineer, your factory has room to improve. Instead of classic test suites, they validate behavior with holdout scenarios and “digital twins,” simulated clones of every external service the software talks to.</p><p>They’re not alone. A Nashville agency, Twin Sun, built a factory called Scarif and reports that around 70% of its pull requests are now approved autonomously. Others are documenting the same climb from “AI writes, human reviews” to “nobody reviews.”</p><p>Notice what changed. Nobody in these setups reviews code line by line, because at this speed nobody <em>can</em>. Review moves up a level:</p><ul><li><strong>Humans</strong> write specs, design scenarios, and own the architecture.</li><li><strong>Agents</strong> write the code, and other agents check it for quality, security, and documentation.</li><li><strong>The output</strong> is tested functionally, against behavior, not against how the code looks.</li></ul><p>If that feels reckless, remember we already work this way one level down. Nobody reviews the machine code their compiler produces. We review the source and trust the toolchain. The factory just moves “source” up one more step: the spec becomes the source, and the code becomes a build artifact.</p><p>That idea has a growing camp behind it. Chad Fowler (who, fittingly, co-created RubyGems back in 2004) calls it the <strong>Phoenix Architecture</strong>: just as we learned to replace servers instead of nursing them along, we should regenerate code instead of maintaining it. Codeplain’s founder puts it even more bluntly: code should be regenerated, not maintained. GitHub released Spec Kit to make specs something agents can act on directly.</p><p>There are serious critics, too, and they deserve a hearing. A Stanford Law CodeX piece points out a real trust problem: when the same AI model writes the code and checks it, the independence between builder and checker shrinks. Not every team will or should go fully dark. But the direction is clear.</p><h3>The part nobody is talking about: factories feeding factories possibly the next bottleneck</h3><p>Most writing about software factories looks at one team, one codebase, one factory. But software doesn’t live alone. Remember Era 4: everything we build sits on top of other people’s packages.</p><p>So play it forward. What happens when the libraries and frameworks you depend on are <em>also</em> built by factories?</p><p>A library maintained by a factory can change many times a day. Every one of those changes is new churn for everyone downstream. Their factories react and rewrite, which creates new churn for <em>their</em> downstream. You get a feedback loop: factories generating work for other factories, at machine speed.</p><p>My first instinct was that this ends with infinite agents burning infinite energy (alas, the infinite software). But let’s stay realistic: that can’t happen. Something will cap it long before that, just like something capped each of the eras above. A new bottleneck will emerge.</p><p>But I honestly don’t know what. And I don’t think anyone does yet. So instead of pretending to have answers, here are the questions I think matter:</p><ol><li><strong>What caps the loop?</strong> Compute cost, energy, or simply how fast we can verify that the output is correct?</li><li><strong>Will the ecosystem push back?</strong> Maybe we’ll see a new premium on stability: frozen interfaces, “slow” libraries, long-term contracts between components that factories aren’t allowed to touch.</li><li><strong>Does cheap code mean more code?</strong> Economists call it the Jevons paradox: when something gets more efficient, we often end up using <em>more</em> of it, not less. Cheap software might just mean vastly more software, created at a much bigger scale. What if the norm shifts from using “big box” software to generating our own?</li><li><strong>Who owns the spec?</strong> If no human owns the code anymore, the spec becomes the real product. Who writes it, who reviews it, and who is accountable when it’s wrong?</li><li><strong>Can AI also reduce churn?</strong> Factories could just as well work towards removing dependencies, consolidating frameworks, and generating small, optimized, self-contained code. The same tool that speeds up the loop might be the one that slows it down. Like finally removing that one dependency that changes constantly but is only used once, by a single sub-dependency!</li></ol><p>I genuinely don’t know which way this goes. My guess is we’ll only find out when we get there.</p><h3>Wrapping up</h3><p>Punch cards, boxed versions, patches, package managers, continuous delivery. Each step removed one thing that slowed software down, and each time, software changed faster. The autonomous software factory isn’t a sudden AI revolution. It’s the next step on a staircase we’ve been climbing for 60 years, and some teams are already standing on it.</p><p>Again, as I mentioned at the beginning, this isn’t a doomsday talk about AI taking developers’ jobs.</p><p>I recently had a kitchen-table discussion about this with my dad. He’s in his mid 60s, with more than 40 years of software engineering experience. I’m in my late 30s, with around 16. My point was simple, and I hope it convinced him: unlike his generation, most of my generation can’t read or write assembly code anymore. We grew up trusting the compiler, the runtime, and the framework(s). What’s happening now is the emergence of a new level of abstraction, where most future developers will need to learn to trust the AI-driven software factory to generate good, performant code. Not all of us, but most of us.</p><p>What happens when every step of the staircase is run by machines, and those machines start feeding each other work, is the genuinely open part. I’d love to hear what you think caps the loop. Drop it in the comments!</p><h3>Sources and further reading</h3><ul><li><a href="https://dfarq.homeip.net/?p=37132">Harvard Mark I and the origin of “patch” (dfarq.homeip.net)</a></li><li><a href="https://en.wikipedia.org/wiki/SHARE_(computing)">SHARE (Wikipedia)</a></li><li><a href="https://www.computerhistory.org/revolution/mainframe-computers/7/172">Computer History Museum — Software Becomes a Product</a></li><li><a href="https://en.wikipedia.org/wiki/Patch_Tuesday">Patch Tuesday (Wikipedia)</a></li><li><a href="https://en.wikipedia.org/wiki/Steam_(service)">Steam (Wikipedia)</a></li><li><a href="https://www.oreilly.com/pub/a/web2/archive/what-is-web-20.html?page=4">Tim O’Reilly — What Is Web 2.0, “End of the Software Release Cycle”</a></li><li><a href="https://csmonitor.com/Technology/Horizons/2009/0707/gmail-says-bye-bye-to-beta">CS Monitor — Gmail says bye-bye to beta (2009)</a></li><li><a href="https://nesbitt.io/2025/11/15/package-manager-timeline.html">Andrew Nesbitt — Package manager timeline</a></li><li><a href="https://paulhammond.org/2009/06/velocity/10deploys.pdf">Allspaw &amp; Hammond — 10+ Deploys Per Day (Velocity 2009 slides)</a></li><li><a href="https://www.slideshare.net/slideshow/devops-and-aws/53134884">AWS slides — deployments at Amazon.com every ~11.6s</a></li><li><a href="https://developer.chrome.com/blog/faster-release-cycle/">Chrome blog — Speeding up Chrome’s release cycle (2021)</a></li><li><a href="https://thehackernews.com/2015/05/microsoft-windows10.html">The Hacker News — Windows 10 as “the last version of Windows” (2015)</a></li><li><a href="https://www.theregister.com/2016/03/23/npm_left_pad_chaos">The Register — left-pad breaks thousands of projects (2016)</a></li><li><a href="https://home.cern/?p=12408">CERN — Log4Shell and the inventory problem</a></li><li><a href="https://dora.dev/quickcheck/2019/results">DORA 2019 performance profiles</a></li><li><a href="https://en.wikipedia.org/wiki/Lehman%27s_laws_of_software_evolution">Lehman’s laws of software evolution (Wikipedia)</a></li><li><a href="https://en.wikipedia.org/wiki/Jevons_paradox">Jevons paradox (Wikipedia)</a></li><li><a href="https://simonwillison.net/2026/Jan/28/the-five-levels/">Simon Willison — The Five Levels: from Spicy Autocomplete to the Dark Factory</a></li><li><a href="https://conffab.com/elsewhere/strongdm-software-factory/">StrongDM Software Factory (summary)</a></li><li><a href="https://law.stanford.edu/2026/02/08/built-by-agents-tested-by-agents-trusted-by-whom/">Stanford Law CodeX — Built by Agents, Tested by Agents, Trusted by Whom?</a></li><li><a href="https://www.zenml.io/llmops-database/building-an-ai-powered-software-factory-with-autonomous-code-generation-and-review">Twin Sun’s Scarif factory (ZenML case study)</a></li><li><a href="https://chadfowler.com/regenerative-software/3mjfruwwuck2d/">Chad Fowler — The Phoenix Architecture</a></li><li><a href="https://thenewstack.io/codeplain-spec-driven-regenerative-code/">The New Stack — Codeplain and regenerative code</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=18bc91364b6d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[UX Case Study: Phoneception]]></title>
            <link>https://medium.com/design-bootcamp/ux-case-study-phoneception-6d540f54855a?source=rss-f610ce5a90f2------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d540f54855a</guid>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[case-study]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[games]]></category>
            <category><![CDATA[game-development]]></category>
            <dc:creator><![CDATA[Daniel Hodvogner]]></dc:creator>
            <pubDate>Wed, 08 Feb 2023 14:02:30 GMT</pubDate>
            <atom:updated>2023-02-10T05:26:26.068Z</atom:updated>
            <content:encoded><![CDATA[<p>During this project my assignment was to develop a main menu for touch-based devices for a casual freemium game, with the aim of incorporating multiple functions and having the ability to expand seamlessly.</p><p>Games like GTA 4 or 5 and Animal Crossing: New Horizon feature in-game mobile devices that resemble real-life phones. This enhances the realism of the game and allows for various in-game functions, including receiving text messages with mission details, making phone calls to interact with non-playable characters, and managing inventory, among others.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kJRT8AuhBevgWpIIbPskEA.png" /></figure><p>Initially, my approach was to utilize a similar system for this project. However, I faced a challenge in how to incorporate this without sacrificing the limited screen space of a mobile phone. My aim was to create a believable “phoneception” that wouldn’t take up to much screen space. To overcome this challenge, I tried to transform the typical in-app purchase bar — commonly seen in casual freemium games - into a more interactive element.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tNDzmw2dX4TYc34SSUXclg.png" /><figcaption>My first iteration: <a href="https://www.figma.com/proto/T92MZSlaBEnYzHm4t74RPJ/Game-UX?node-id=31%3A12135&amp;scaling=min-zoom&amp;page-id=31%3A12090&amp;starting-point-node-id=31%3A12122">Figma prototype</a></figcaption></figure><p>The main focus of my design was the notification loop, as the game heavily relies on resource management and repeated actions. I envisioned each feature as an app on the player’s virtual phone. These apps could send “push notifications” to grab the player’s attention. By interacting with these notifications, the player is placed in context with a specific function and able to perform the necessary actions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VNt-_1rd42KUGX2fah2t8g.png" /><figcaption>The core loop: <a href="https://www.figma.com/proto/T92MZSlaBEnYzHm4t74RPJ/Game-UX?node-id=31%3A11354&amp;scaling=contain&amp;page-id=0%3A1&amp;starting-point-node-id=31%3A11691">Figma prototype</a></figcaption></figure><p>This system also offers a simple solution for managing multiple concurrent events. Notification counters can be displayed on each app or they can be stacked on the top of each other inside the virtual phone, similarly to real-life notifications on your real phone’s status bar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c_nHViiZc3zHvrowqfd_Lg.png" /><figcaption>Notification Stack: <a href="https://www.figma.com/proto/T92MZSlaBEnYzHm4t74RPJ/Game-UX?node-id=31%3A12945&amp;scaling=contain&amp;page-id=0%3A1&amp;starting-point-node-id=31%3A12880">Figma prototype</a></figcaption></figure><p>To further improve the user experience and the ease of use, the virtual phone could respond to player actions in the game world. For example, when a player selects a production building (that produces a resource from components X, Y, and Z), the virtual phone interface could automatically open the “Inventory” to quickly display the player’s current amount of X, Y, and Z resources.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GxWg-pQiFmulXzshBov-TQ.png" /><figcaption>Building selection: <a href="https://www.figma.com/proto/T92MZSlaBEnYzHm4t74RPJ/Game-UX?node-id=123%3A1215&amp;scaling=contain&amp;page-id=123%3A1212&amp;starting-point-node-id=123%3A1215">Figma prototype</a></figcaption></figure><p>I believe this menu system offers great flexibility and can easily be expanded to support additional game features. Although, there are some limitations in the current prototype. For example, the menu only covers half the screen width, which can be easily remedied by “launching out” each or specific applications to fill the entire screen. This will eliminate the need to compress all the information into a small area or rely heavily on scrolling.</p><p>Another concern I have is the common problem with this type of games — placing a large portion of the gameplay in menus. In my view, games are a way for us to escape from our daily chores, so why would we want to look at a phone on our own phone? To address this, we need creative game design that incorporates mini-games and various clever interactions with the game world, which shift the focus from the UI to the gameplay.</p><p>As a freelancer on this particular project, my role was to envision the basic interactions for an unannounced game, based on limited information. As a result, my ideas remained in the form of low-fidelity mock-ups and may not be implemented exactly as envisioned. However, I believe the core elements of this concept can be easily adapted into other types of games — beyond just casual mobile games — or even into regular applications.</p><p>If you found this article helpful and informative, I would be grateful if you could give it a “Clap.” <br>If you have any thoughts or questions about the topic, don’t hesitate to leave a comment or reach out to me through <a href="https://daniel.hodvogner.hu/">my portfolio page</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d540f54855a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/ux-case-study-phoneception-6d540f54855a">UX Case Study: Phoneception</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The edge of Design]]></title>
            <link>https://uxdesign.cc/the-edge-of-design-7eb0cec4d2a7?source=rss-f610ce5a90f2------2</link>
            <guid isPermaLink="false">https://medium.com/p/7eb0cec4d2a7</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[marketing]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[web]]></category>
            <dc:creator><![CDATA[Daniel Hodvogner]]></dc:creator>
            <pubDate>Wed, 16 Oct 2019 20:31:02 GMT</pubDate>
            <atom:updated>2019-10-18T00:24:45.268Z</atom:updated>
            <content:encoded><![CDATA[<p>By finding the border between design and development, I want to help both design practitioners and developers to understand why we can experience some setbacks in our day-to-day works.</p><p>In this article, I’m going to focus on web development, simply because I have more experience with it from my profession. Although I’m sure, it can be applied to other areas too.</p><p>Let’s take a look at how your designs realised with a modern web development technology stack.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/312/1*EqXGIJzBtcgxwbTyiTj0pg.png" /><figcaption>From Design to Application lifecycle</figcaption></figure><h3>Design Language (“Style”)</h3><p>We, as designers usually choose a “style”. It may be conscious or unconscious, but before we start our design process, we are going to use one or more Design Languages anyway.</p><p>This topic would deserve a whole article — or maybe a complete book — so allow me to list just some examples for further reading and move along.</p><ul><li><a href="https://material.io/design/">Material Design</a></li><li><a href="https://www.ibm.com/design/language/">IBM Design Language</a></li><li><a href="https://en.wikipedia.org/wiki/Flat_design">Flat Design</a></li></ul><h3>Design System</h3><p>To summarise what is a Design System I ‘d like to use the following quote:</p><blockquote>A Design System is the single source of truth which groups all the elements that will allow the teams to design, realize and develop a product. Not a <strong>deliverable</strong>.</blockquote><p>Source: <a href="https://uxdesign.cc/everything-you-need-to-know-about-design-systems-54b109851969">Everything you need to know about Design Systems</a></p><p>I’d like to see them as the successor of the Company Design Guideline books and handouts. They are living and an ever-evolving collection of colour usage, typography rules, branding guides, practices, principles, et cetera.</p><p>In many cases, the Design Language and the Design System to be considered as one entity. However, I feel like it’s essential to make the distinction between the higher-level Design concepts and philosophies — the Design Language — and the lower-level definitions, guidelines — the Design System.</p><ul><li><a href="https://www.carbondesignsystem.com/">Carbon Design System</a></li></ul><h3>CSS/Component Library</h3><p>A CSS or <strong>Component Library</strong> should implement the principles and elements defined by the Design System and enable developers to use them in the process of creating applications. They are also a way to ensure whenever the Design System changes, the modifications will be reflected in every application without a lot of extra work.</p><p><a href="https://getbootstrap.com/">Bootstrap</a> is I think an excellent example of this.</p><p>But feel free to look back into the previous section, most of the mentioned Design Systems have their component implementation.</p><h3>The edge of Design</h3><p>And now, we have reached or maybe already surpassed the “edge of Design”.</p><p>In reality, Design Systems are trying to be the Component Libraries too. To achieve this, it usually requires designers to understand many core concepts of the frontend development — CSS, HTML, JavaScript and Frontend Frameworks also. Or a very close collaboration between them and other developers.</p><p>We can hear a lot about DesignOps recently. DesignOps teams are idealistically in charge of only maintaining the Design System itself. I find in many companies this is simply unachievable. They don’t have the capacity to have a whole team merely focusing on this scope. In the other side, I heard much criticism from developers that such groups are struggling to keep up with the ever-changing standards and technologies.</p><p>In my opinion, this is the most recent hot topic, and I believe in many companies, design and developer teams are trying to work out solutions around the clock. Also, I’m sure it spawns many discussions about roles and responsibilities between team leaders, managers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K0SjkDif-SotdICr3NwRKg.png" /><figcaption>Source: <a href="https://unsplash.com/photos/KCzCfkic-ig">Unsplash</a></figcaption></figure><h3>Frontend Framework Wrappers</h3><p>For designers, it may be a new concept; for developers, they are daily struggles. Frontend development evolves lightning-fast. What was one day considered as an industry-standard on the other day, can be labelled as bad practice. It will be highly advised to avoid at any cost in the developer communities. Take jQuery, for example.</p><p>That what spawned wrappers for older but still popular Component Libraries. To help their transition into newer Frameworks because let’s face it, most of them are not capable of following along. Yes, even Bootsrap 4 is a bit outdated because many components of it still require jQuery and other obsolete third party libraries. Not to mention, in many cases, it’s hard or impossible — because of these dependencies — to include them into a modern build pipeline.</p><ul><li><a href="https://ng-bootstrap.github.io/#/home">ng-bootstrap</a></li><li><a href="https://react-bootstrap.github.io/">react-bootstrap</a></li><li><a href="https://bootstrap-vue.js.org/">bootstrap-vue</a></li></ul><h3>Frontend Frameworks</h3><p>The fellow reader developer already knows for sure what they are. For designers, I believe it’s enough to understand that they are technological fundamental building blocks for any web application.</p><p>As a designer, if you are working with web applications, I believe you must dig into them at least a little bit.</p><p>To mention the three most popular at this exact moment.</p><ul><li><a href="https://angular.io/">Angular</a></li><li><a href="https://vuejs.org/">Vue</a></li><li><a href="https://reactjs.org/">React</a></li></ul><h3>Applications</h3><p>They are the end goal, our daily job, what we design/develop for our clients. I think no further explanation is needed for them :)</p><p>Now, I like to encourage you to think about your application(s) and look back to the previous sections.</p><ul><li>What Design Language influences do you have?</li><li>What kind of Design Systems do you use?</li><li>What Component Library do you — or you developers — use?</li><li>What Frontend Framework drives your applications?</li><li>Is there a need for a Wrapper between your Component Library/Design System?</li></ul><h3>What does the future hold?</h3><p>Currently, the frontend world is buzzing about Web Components. Idealistically they will be the ideal technology to create a new generation of Component Library. They will allow developers — or designers — to build reusable, maintainable, framework independent components and eliminate the need for Wrappers.</p><p>And let’s not get into details about Micro Frontends, what may be going to reshape the whole frontend development world completely.</p><ul><li><a href="https://developer.mozilla.org/en-US/docs/Web/Web_Components">Web Components</a></li><li><a href="https://micro-frontends.org/">Micro Frontend</a></li></ul><h3>Final Thoughts</h3><p>Maybe I’m not the first one who “found” the edge of Design. I’m sure there are other edges as-well. Despite all this, it was a significant discovery for me. It helped me to see things under a different light. Now that I’m able to make sense of what is happening. I can start to think about solutions and strategies.</p><p>Now, I’d like to know what you think all about this. What is your perspective as a designer, as a developer?</p><p>So please feel free write down your thoughts on the responses section below.<br>Also, if you liked this article, please give me a clap. 😃</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7eb0cec4d2a7" width="1" height="1" alt=""><hr><p><a href="https://uxdesign.cc/the-edge-of-design-7eb0cec4d2a7">The edge of Design</a> was originally published in <a href="https://uxdesign.cc/">UX Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design tools are holding us back?]]></title>
            <link>https://medium.com/@dhodvogner/design-tools-are-holding-us-back-d505497114d5?source=rss-f610ce5a90f2------2</link>
            <guid isPermaLink="false">https://medium.com/p/d505497114d5</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[web-design]]></category>
            <category><![CDATA[tools-for-design]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Daniel Hodvogner]]></dc:creator>
            <pubDate>Wed, 24 Jul 2019 13:44:09 GMT</pubDate>
            <atom:updated>2019-08-01T15:58:41.508Z</atom:updated>
            <content:encoded><![CDATA[<h3>Are Design tools holding us back?</h3><p>I recently read this article called <a href="https://uxdesign.cc/design-tools-are-holding-us-back-1aca266b333e">Design tools are holding us back</a>. It made me think, and that’s why I’d decided to share my opinion.</p><p>My name is Daniel Hodvogner and I’m a lucky/unlucky front-end developer who is involved with UI/UX design since my university years. For a long-long time, I thinking about how can we create design tools that are convenient for designers, and also helpful for the developers. Tools what enable teams to rapidly implement new designs, which can become part of a modern development pipeline.</p><h3>Core concept</h3><p>Coding and Design they have a very different mentality and focus.</p><p>While coding HTML/CSS, we focus on readability, transparency, reusability of the code itself, not just the visual outcome what our browser will render from our code.</p><p>Oppositely when we design we have to focus on the on-screen information architecture, the general look and feel, we have to create visual hierarchy and consistency across the whole application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x_6QGdo6yg2I9XYl34qxVw.png" /></figure><p>So, how we try to replace our current design tools? By creating new applications which are capable of visual design (with or without the box-model) and generate HTML/CSS. This raises a few concerns on my side:</p><h3>What’s wrong with the generated code?</h3><p>Experienced front-end developers can write tight well-optimized HTML. Keeping the DOM un-heavy is optimal for the browsers to render the pages faster and, it also helps them to maintain the code with ease. Not to mention usually they are the experts whose figure out how to separate the application into (web)components but keep in mind these components usually very-very different from those what you have in your design system!</p><p>With generated CSS code I only have one issue: We don’t use CSS anymore. In modern front-end development 99.9%, we use SCSS or a similar superset language what can be transpiled into CSS. During this process, the browser-specific (aka: -webkit, -moz) attributes generated automatically (so we don’t need to care about them anymore) unused selectors are removed to decrease package size and improve load speeds and let’s not talk about media queries, mixins, variables and other tricks.</p><h3>Design handover and version control</h3><p>In my “idealistic” dream tool design handover is not needed anymore, whenever the design is changed it automatically reflected into the front-end code and vice versa. To be honest I don’t have much experience with tools like Framer or Webflow which promise of achieving something like this but with the rapid evolution of front-end framework trends, I’m sceptical that any of these tools will be able to keep up and deliver on such promises. And they can be seamlessly integrated into any modern development process without creating new and unnecessary maintenance and changes in the development pipeline.</p><p>And let’s not forget about our developer friends. They will surely add a lot of framework-specific extra attributes, elements like *ngFors v-fors all over our generated HTML. They will remove all our placeholder elements and put loops everywhere “destroying” our well crafted and representative state of our screens. Let me ask the question: How these changes should be reflected back into your design?</p><p>Also, how can we showcase to our clients our awesome solution to that nasty edge case what would need 16 duplicated artboard in a Sketch prototype, with these new “design to code” software?</p><p>I don’t know the answers, maybe I just lack the experience, so please feel free to share yours if you have any and I also promise when I find the time to mess around with them more I will update this article (or write a new one).</p><h3>Conclusion</h3><p>Unfortunately, I don’t have the “correct answer”, I’m not able to share the best practice or talking about revolutionary new industry standard. I also struggle in my work to find the balance and the most effective way to support my two roles in my own team.</p><p>As a well-experienced developer, I like better writing the front-end code myself and let my colleges fill the rest more “back-endish” stuff (states, services etc.) I also like to build SCSS system on my own with clever mixins and multiple variables to help to maintain both the codebase and the visual consistency in the long run.</p><p>On the other hand, when I design, I need the freedom of Sketch. Quickly grouping stuff together, rearranging the whole screen multiple times, creating multiple layouts, iterate quickly and with a few clicks — and many duplicated artboards — create inVision prototypes to help me back up our ideas when I explain them to our clients.</p><p>With the upcoming web components and microframeworks, a lot could change in the future, but currently, I don’t see any viable next-gen tools what could drastically change our ways of designing. I believe we need close collaboration between the designer and developer community to work out new solutions, maybe new technologies that can seamlessly integrate into a typical development pipeline, and will bring the design process to a whole new level in the future.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d505497114d5" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>