<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: ludy.dev</title>
    <description>The latest articles on DEV Community by ludy.dev (@lyyluca).</description>
    <link>https://dev.to/lyyluca</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F3749447%2F916d0753-f6e8-4be4-9608-6ef818f69843.jpg</url>
      <title>DEV Community: ludy.dev</title>
      <link>https://dev.to/lyyluca</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/lyyluca"/>
    <language>en</language>
    <item>
      <title>Building a Browser Arcade: Three Game Loops, One Entry Point</title>
      <dc:creator>ludy.dev</dc:creator>
      <pubDate>Sat, 14 Nov 2026 05:44:25 +0000</pubDate>
      <link>https://dev.to/lyyluca/building-a-browser-arcade-three-game-loops-one-entry-point-1af4</link>
      <guid>https://dev.to/lyyluca/building-a-browser-arcade-three-game-loops-one-entry-point-1af4</guid>
      <description>&lt;p&gt;I’m Ludy, and I built &lt;a href="https://ludyplay.com" rel="noopener noreferrer"&gt;LudyPlay&lt;/a&gt;, a free browser-game portal with open-answer trivia, a 15-minute survival run, and a coastal motorcycle race.&lt;/p&gt;

&lt;p&gt;The interesting engineering question is not just how to make a game. It is how to give very different games a shared entry point without pretending they behave the same way.&lt;/p&gt;

&lt;h2&gt;
  
  
  The browser is the common platform
&lt;/h2&gt;

&lt;p&gt;At the platform level, this is a web project: players access games through a browser rather than installing a native package.&lt;/p&gt;

&lt;p&gt;I’m keeping this write-up framework-neutral because a specific framework, backend, or hosting setup is not documented here. The architectural discussion is about responsibilities and trade-offs, not an invented stack breakdown.&lt;/p&gt;

&lt;p&gt;The useful separation is between the portal layer and the gameplay layer. The portal helps someone choose an experience. Each game then needs its own rules, input handling, and lifecycle.&lt;/p&gt;

&lt;h2&gt;
  
  
  Different games need different state models
&lt;/h2&gt;

&lt;p&gt;For open-answer trivia, the central flow is submission and evaluation. A typed answer introduces questions that multiple-choice interfaces avoid: whitespace, capitalization, punctuation, and accepted variations.&lt;/p&gt;

&lt;p&gt;A useful evaluation pipeline to consider is normalization followed by an explicit acceptance check. Broad fuzzy matching needs care: being generous with spelling can accidentally turn a wrong answer into a correct one.&lt;/p&gt;

&lt;p&gt;A timed survival game raises another class of questions. Elapsed time, update frequency, and rendering frequency are related, but they should not automatically be treated as identical.&lt;/p&gt;

&lt;p&gt;For a racing experience, responsiveness becomes the obvious thing to inspect. Input should not depend on how often unrelated interface elements update.&lt;/p&gt;

&lt;p&gt;These are design considerations, not claims about undocumented implementation details.&lt;/p&gt;

&lt;h2&gt;
  
  
  Keep state boundaries boring
&lt;/h2&gt;

&lt;p&gt;The boundary I would recommend is simple: each game owns its session state, while shared navigation stays outside that state.&lt;/p&gt;

&lt;p&gt;That reduces the temptation to build one enormous state object containing trivia answers, survival timers, and racing controls. Shared presentation does not require shared gameplay logic.&lt;/p&gt;

&lt;p&gt;It also creates clearer testing questions. Can a session restart cleanly? What happens when a tab becomes inactive? Does navigation leave anything running?&lt;/p&gt;

&lt;h2&gt;
  
  
  What I want feedback on
&lt;/h2&gt;

&lt;p&gt;Try &lt;a href="https://ludyplay.com" rel="noopener noreferrer"&gt;LudyPlay&lt;/a&gt; and tell me where the experience feels awkward.&lt;/p&gt;

&lt;p&gt;I’m especially interested in answer acceptance for trivia and how the survival session length feels. Specific examples are much more useful than a general "looks good."&lt;/p&gt;

</description>
      <category>discuss</category>
    </item>
    <item>
      <title>Building a BaZi Calculator: The Hard Part Is Explaining the Rules</title>
      <dc:creator>ludy.dev</dc:creator>
      <pubDate>Sat, 14 Nov 2026 05:43:39 +0000</pubDate>
      <link>https://dev.to/lyyluca/building-a-bazi-calculator-the-hard-part-is-explaining-the-rules-42ph</link>
      <guid>https://dev.to/lyyluca/building-a-bazi-calculator-the-hard-part-is-explaining-the-rules-42ph</guid>
      <description>&lt;p&gt;I built &lt;a href="https://bazicue.com" rel="noopener noreferrer"&gt;BaZi Cue&lt;/a&gt;, a free calculator for BaZi’s Four Pillars, Day Master, and Five Elements.&lt;/p&gt;

&lt;p&gt;The interesting engineering problem isn’t drawing a chart. It’s making a calendar-dependent result understandable without hiding the conventions that produced it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Start with the calculation contract
&lt;/h2&gt;

&lt;p&gt;For a project like this, "convert a birth date into a chart" is not a complete specification.&lt;/p&gt;

&lt;p&gt;You need to decide what information the calculation accepts, which calendar conventions apply, and how boundary cases should behave. A result can look completely plausible while following different assumptions from the calculator beside it.&lt;/p&gt;

&lt;p&gt;That means the calculation contract deserves the same attention as the interface.&lt;/p&gt;

&lt;p&gt;A useful implementation model is input normalization, calendar conversion, pillar derivation, and presentation. These are architectural boundaries to think through, not a claim about a particular framework or library in the deployed application.&lt;/p&gt;

&lt;h2&gt;
  
  
  Keep derived values traceable
&lt;/h2&gt;

&lt;p&gt;The Day Master is associated with the heavenly stem of the day pillar. It shouldn’t become a separate piece of state that can drift away from the chart.&lt;/p&gt;

&lt;p&gt;The same principle applies to element-related output: labels and summaries should come from a consistent underlying representation.&lt;/p&gt;

&lt;p&gt;If I were reviewing a similar calculator, I’d ask whether the display layer can accidentally disagree with the calculation layer. Duplicated lookup logic is an easy way to create that problem.&lt;/p&gt;

&lt;h2&gt;
  
  
  Test the boundaries, not just ordinary dates
&lt;/h2&gt;

&lt;p&gt;The most useful test cases are often the least convenient ones.&lt;/p&gt;

&lt;p&gt;Dates near relevant calendar transitions, time boundaries, and input-validation limits deserve explicit attention. Reference cases also need their assumptions recorded; otherwise, a disagreement between two calculators doesn’t tell you which implementation is wrong.&lt;/p&gt;

&lt;p&gt;A good fixture explains both the expected output and the convention it assumes.&lt;/p&gt;

&lt;h2&gt;
  
  
  A note on the stack
&lt;/h2&gt;

&lt;p&gt;BaZi Cue is a browser-accessible web calculator. I’m keeping this write-up focused on the calculation and presentation architecture rather than naming an unverified framework, hosting provider, or backend.&lt;/p&gt;

&lt;p&gt;The transferable lesson is separation of concerns: calculation rules should be inspectable independently of UI choices.&lt;/p&gt;

&lt;h2&gt;
  
  
  Feedback I’d find useful
&lt;/h2&gt;

&lt;p&gt;The site is free and doesn’t require an account.&lt;/p&gt;

&lt;p&gt;I’d love feedback on the explanations, especially from developers familiar with calendrical software. What boundary cases would you test first? What would make a calculation rule sufficiently clear to reproduce?&lt;/p&gt;

&lt;p&gt;Try &lt;a href="https://bazicue.com" rel="noopener noreferrer"&gt;BaZi Cue&lt;/a&gt; and tell me which assumption you’d want documented more explicitly.&lt;/p&gt;

</description>
      <category>discuss</category>
    </item>
    <item>
      <title>Building an Image-to-Pattern Editor Is Really a Grid Design Problem</title>
      <dc:creator>ludy.dev</dc:creator>
      <pubDate>Sat, 14 Nov 2026 05:42:53 +0000</pubDate>
      <link>https://dev.to/lyyluca/building-an-image-to-pattern-editor-is-really-a-grid-design-problem-3b7g</link>
      <guid>https://dev.to/lyyluca/building-an-image-to-pattern-editor-is-really-a-grid-design-problem-3b7g</guid>
      <description>&lt;p&gt;I built &lt;a href="https://motifdraft.com" rel="noopener noreferrer"&gt;MotifDraft&lt;/a&gt; to turn images into cross stitch, crochet, and bead charts. Users can edit colors and grids, then print a pattern. It starts free in the browser without an account.&lt;/p&gt;

&lt;p&gt;The interesting engineering question is not simply how to display an image. It is how to turn that image into an editable representation that still makes sense as a physical project.&lt;/p&gt;

&lt;h2&gt;
  
  
  Start with the data model, not the canvas
&lt;/h2&gt;

&lt;p&gt;A useful conceptual model is a grid of cells, with each cell referring to a color in a palette.&lt;/p&gt;

&lt;p&gt;That separates three concerns: the source image, the editable pattern, and the way the pattern is displayed.&lt;/p&gt;

&lt;p&gt;This is an architectural explanation, not a claim about a particular framework or a published source implementation. I’m keeping the stack details out rather than presenting an unverified dependency list.&lt;/p&gt;

&lt;p&gt;The important boundary is that a pattern should be treated as structured data, not merely a screenshot of a converted image.&lt;/p&gt;

&lt;h2&gt;
  
  
  Resolution becomes a product decision
&lt;/h2&gt;

&lt;p&gt;In ordinary image work, more pixels often means more detail. In a craft chart, more cells can also mean a larger and more demanding project.&lt;/p&gt;

&lt;p&gt;That makes grid controls part of the core workflow rather than a secondary settings panel.&lt;/p&gt;

&lt;p&gt;A useful test is to compare a simple icon with a detailed photograph. Both are valid image inputs, but they expose very different problems once reduced to cells.&lt;/p&gt;

&lt;p&gt;The icon tests edge clarity. The photograph tests whether small tonal differences overwhelm the subject.&lt;/p&gt;

&lt;h2&gt;
  
  
  Palette changes need clear semantics
&lt;/h2&gt;

&lt;p&gt;Color editing raises another architectural question: are you changing one cell, a palette entry, or every occurrence of a color?&lt;/p&gt;

&lt;p&gt;Those actions may look similar in the interface, but they imply different state changes.&lt;/p&gt;

&lt;p&gt;Making the scope of an edit obvious is just as important as making it fast. Otherwise, a technically correct operation can still feel unpredictable.&lt;/p&gt;

&lt;h2&gt;
  
  
  Printing is another rendering target
&lt;/h2&gt;

&lt;p&gt;A chart that looks good in an interactive editor is not automatically useful on paper.&lt;/p&gt;

&lt;p&gt;Print layout deserves separate attention: readable cells, sensible scaling, and a clear relationship between the screen preview and the printed result.&lt;/p&gt;

&lt;p&gt;The broader lesson is to keep the pattern representation independent from any one view.&lt;/p&gt;

&lt;p&gt;Try MotifDraft with an awkward image and tell me where the editing model becomes confusing. That feedback is more useful than a framework popularity contest.&lt;/p&gt;

</description>
      <category>productivity</category>
    </item>
    <item>
      <title>Building QiLoom: Calendar Conversion Is a Domain Modeling Problem</title>
      <dc:creator>ludy.dev</dc:creator>
      <pubDate>Fri, 30 Oct 2026 04:53:27 +0000</pubDate>
      <link>https://dev.to/lyyluca/building-qiloom-calendar-conversion-is-a-domain-modeling-problem-3d95</link>
      <guid>https://dev.to/lyyluca/building-qiloom-calendar-conversion-is-a-domain-modeling-problem-3d95</guid>
      <description>&lt;p&gt;I’m building &lt;a href="https://qiloom.com" rel="noopener noreferrer"&gt;QiLoom&lt;/a&gt;, a free website for Gregorian and Chinese lunar calendar conversion, birthday lookup, zodiac lookup, completed age, and family milestones.&lt;/p&gt;

&lt;p&gt;The interesting engineering problem isn’t the date picker. It’s deciding exactly what a date represents.&lt;/p&gt;

&lt;p&gt;A scope note before the technical discussion: I’m not publishing a framework, hosting, or dependency inventory here. The useful part of this write-up is the domain model and the implementation questions it creates, not an invented stack tour.&lt;/p&gt;

&lt;h2&gt;
  
  
  A calendar date is not automatically a timestamp
&lt;/h2&gt;

&lt;p&gt;A birthday is usually a civil date, not an instant.&lt;/p&gt;

&lt;p&gt;That distinction matters in JavaScript. Moving a date through UTC serialization and local rendering can introduce a day shift that has nothing to do with the calculation the user requested.&lt;/p&gt;

&lt;p&gt;For this kind of tool, I favor reasoning about year, month, and day as explicit components. Time zones should enter the model only when the operation actually requires them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lunar dates need more than three numbers
&lt;/h2&gt;

&lt;p&gt;A Chinese lunar date needs calendar context, including whether the month is a leap month.&lt;/p&gt;

&lt;p&gt;Conceptually, the input looks more like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="nx"&gt;LunarDate&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="na"&gt;year&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kr"&gt;number&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="nl"&gt;month&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kr"&gt;number&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="nl"&gt;day&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kr"&gt;number&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="nl"&gt;isLeapMonth&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;boolean&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is an illustrative model, not an extract from the production code.&lt;/p&gt;

&lt;p&gt;The important point is that dropping &lt;code&gt;isLeapMonth&lt;/code&gt; can discard information. A UI that hides that distinction can make an otherwise plausible calculation ambiguous.&lt;/p&gt;

&lt;h2&gt;
  
  
  Similar-looking calculations need separate contracts
&lt;/h2&gt;

&lt;p&gt;Completed age, elapsed days, and a baby’s hundredth day are different operations.&lt;/p&gt;

&lt;p&gt;Completed age depends on whether the birthday has occurred in the reference year. Date intervals require an explicit inclusion convention. A milestone calculation needs to explain how the birth date is counted.&lt;/p&gt;

&lt;p&gt;I’d rather have small, separately testable domain functions than one generic helper with a growing collection of boolean flags.&lt;/p&gt;

&lt;h2&gt;
  
  
  Test the boundaries, not just the happy path
&lt;/h2&gt;

&lt;p&gt;The test cases I care about include lunar new year boundaries, leap months, Gregorian leap days, month transitions, and birthdays close to the reference date.&lt;/p&gt;

&lt;p&gt;Round-trip conversion checks are useful too, but they should complement comparison against trusted calendar references—not replace it.&lt;/p&gt;

&lt;p&gt;Try &lt;a href="https://qiloom.com" rel="noopener noreferrer"&gt;QiLoom&lt;/a&gt; and tell me which assumptions the interface should expose more clearly. I’m especially interested in how other developers communicate calendar conventions without overwhelming the form.&lt;/p&gt;

</description>
      <category>ux</category>
    </item>
    <item>
      <title>Building a Game Wiki Hub: The Content Model Is the Hard Part</title>
      <dc:creator>ludy.dev</dc:creator>
      <pubDate>Wed, 28 Oct 2026 02:55:59 +0000</pubDate>
      <link>https://dev.to/lyyluca/building-a-game-wiki-hub-the-content-model-is-the-hard-part-3jj0</link>
      <guid>https://dev.to/lyyluca/building-a-game-wiki-hub-the-content-model-is-the-hard-part-3jj0</guid>
      <description>&lt;p&gt;I’m Ludy, and I’m building &lt;a href="https://chuppa.gg/" rel="noopener noreferrer"&gt;chuppa.gg&lt;/a&gt;, an independent hub for game wikis, beginner guides, character and item references, builds, tier lists, and codes.&lt;/p&gt;

&lt;p&gt;This is a content project, not a developer utility. But the engineering questions behind it are surprisingly interesting: how do you organize information that is interconnected, unevenly structured, and vulnerable to becoming outdated?&lt;/p&gt;

&lt;h2&gt;
  
  
  Start with relationships, not page templates
&lt;/h2&gt;

&lt;p&gt;A character page, a build, and a tier list might all mention the same character. That does not make them interchangeable.&lt;/p&gt;

&lt;p&gt;The reference describes the entity. The build recommends a configuration. The tier list compares options under some set of assumptions.&lt;/p&gt;

&lt;p&gt;A useful conceptual model is:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Game
  -&amp;gt; Reference entries
  -&amp;gt; Beginner guides
  -&amp;gt; Builds
  -&amp;gt; Tier lists
  -&amp;gt; Codes

Recommendation
  -&amp;gt; Referenced entities
  -&amp;gt; Supporting sources
  -&amp;gt; Applicable context
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is a design sketch, not a dump of the production schema. The important distinction is between describing something and recommending something.&lt;/p&gt;

&lt;h2&gt;
  
  
  The stack matters less than the publishing contract
&lt;/h2&gt;

&lt;p&gt;I’m keeping this post stack-neutral rather than presenting an undocumented framework, database, or hosting setup as fact.&lt;/p&gt;

&lt;p&gt;For this kind of site, the architectural contract is the interesting part: content storage feeds validation, validation feeds rendering, and rendering produces navigable pages with useful relationships.&lt;/p&gt;

&lt;p&gt;Whether that pipeline uses files or a database, I would want checks for broken internal references, missing source URLs, duplicate identifiers, and content attached to the wrong game.&lt;/p&gt;

&lt;p&gt;Those checks catch problems that a perfectly healthy build can otherwise publish.&lt;/p&gt;

&lt;h2&gt;
  
  
  Freshness is a modeling problem
&lt;/h2&gt;

&lt;p&gt;A recently edited page is not necessarily a recently verified page.&lt;/p&gt;

&lt;p&gt;That distinction becomes especially important for codes and balance-sensitive recommendations. A typo fix should not imply that someone retested a build.&lt;/p&gt;

&lt;p&gt;My preferred design separates editorial changes from verification events and records what was actually checked. That is a direction for the content model, not a promise of automated verification.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I want feedback on
&lt;/h2&gt;

&lt;p&gt;I’m interested in how other developers handle source relationships and update context in content-heavy applications.&lt;/p&gt;

&lt;p&gt;Would you model a build as structured data with prose attached, or as prose with references embedded? How would you expose uncertainty without covering every page in warnings?&lt;/p&gt;

&lt;p&gt;Take a look at &lt;a href="https://chuppa.gg/" rel="noopener noreferrer"&gt;chuppa.gg&lt;/a&gt; and tell me which relationships you would make more explicit.&lt;/p&gt;

</description>
      <category>discuss</category>
    </item>
    <item>
      <title>Building GamePicks: A Browser Game Directory Is a Data Modeling Problem</title>
      <dc:creator>ludy.dev</dc:creator>
      <pubDate>Sun, 18 Oct 2026 05:38:34 +0000</pubDate>
      <link>https://dev.to/lyyluca/building-gamepicks-a-browser-game-directory-is-a-data-modeling-problem-14el</link>
      <guid>https://dev.to/lyyluca/building-gamepicks-a-browser-game-directory-is-a-data-modeling-problem-14el</guid>
      <description>&lt;p&gt;I built &lt;a href="https://gamepicks.org/" rel="noopener noreferrer"&gt;GamePicks&lt;/a&gt; as a discovery portal for independent browser games made with AI.&lt;/p&gt;

&lt;p&gt;The public-facing flow is small: explore a game, read its creator statement, and follow the link to the original site. From a developer’s perspective, the interesting discussion isn’t another grid of cards. It’s how to represent those relationships without losing context.&lt;/p&gt;

&lt;h2&gt;
  
  
  Start with the content contract
&lt;/h2&gt;

&lt;p&gt;A useful conceptual model separates three things: the game, the creator’s statement, and the destination where someone can play.&lt;/p&gt;

&lt;p&gt;They belong together, but they aren’t interchangeable. A creator statement provides attributed context. An outbound URL provides a destination. Neither should silently become an editorial claim about the game.&lt;/p&gt;

&lt;p&gt;For anyone building a similar directory, I’d start with a record shaped around a title, a description, a creator statement, and an original-site URL. That’s a suggested model, not a dump of GamePicks’ production schema.&lt;/p&gt;

&lt;p&gt;Keeping those responsibilities separate makes later changes easier to reason about.&lt;/p&gt;

&lt;h2&gt;
  
  
  The stack matters less than the boundary
&lt;/h2&gt;

&lt;p&gt;I’m not publishing a verified production stack breakdown here, so I won’t attach a fashionable framework list to the launch.&lt;/p&gt;

&lt;p&gt;Architecturally, this kind of site is a good fit for content-first rendering. A possible implementation would validate records during publishing, render discovery pages from that content, and use ordinary outbound links for the handoff.&lt;/p&gt;

&lt;p&gt;The useful boundary is between discovery and execution. A directory doesn’t need to run someone else’s game to help a player find it.&lt;/p&gt;

&lt;p&gt;That distinction also keeps the scope honest: GamePicks points people to original sites rather than presenting itself as a game engine or hosting platform.&lt;/p&gt;

&lt;h2&gt;
  
  
  External links deserve real engineering attention
&lt;/h2&gt;

&lt;p&gt;The less glamorous questions are the ones I’d prioritize next.&lt;/p&gt;

&lt;p&gt;What happens when a destination changes? How should a temporarily unreachable site differ from a removed game? Should automated link checks trigger review rather than immediate removal?&lt;/p&gt;

&lt;p&gt;A successful HTTP response alone doesn’t prove a game is playable. Redirects, JavaScript requirements, and temporary failures complicate the answer.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I’d like feedback on
&lt;/h2&gt;

&lt;p&gt;I’m interested in how other developers handle attributed statements and external-link health in small content directories.&lt;/p&gt;

&lt;p&gt;Would you keep creator statements as versioned content? What would your minimum useful link-checking workflow look like?&lt;/p&gt;

&lt;p&gt;Explore &lt;a href="https://gamepicks.org/" rel="noopener noreferrer"&gt;GamePicks&lt;/a&gt; and tell me which piece of context you’d want before clicking through to a game.&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>gamedev</category>
      <category>ai</category>
      <category>discuss</category>
    </item>
    <item>
      <title>Building ChartPetal: The Hard Part Is Between the CSV and the Chart</title>
      <dc:creator>ludy.dev</dc:creator>
      <pubDate>Sun, 18 Oct 2026 05:38:11 +0000</pubDate>
      <link>https://dev.to/lyyluca/building-chartpetal-the-hard-part-is-between-the-csv-and-the-chart-3h6o</link>
      <guid>https://dev.to/lyyluca/building-chartpetal-the-hard-part-is-between-the-csv-and-the-chart-3h6o</guid>
      <description>&lt;p&gt;That’s an architectural model, not a claim about ChartPetal’s exact internal implementation.&lt;/p&gt;

&lt;h2&gt;
  
  
  The stack matters less than the contract
&lt;/h2&gt;

&lt;p&gt;I’m keeping this post library-agnostic rather than publishing an unverified framework or model list.&lt;/p&gt;

&lt;p&gt;The important stack boundaries are the web interface, tabular-data handling, AI interpretation, and visualization layer. Whatever libraries sit underneath, each boundary needs an explicit contract.&lt;/p&gt;

&lt;p&gt;For example, a proposed chart specification should reference columns that actually exist. Numeric operations should require numeric inputs. An aggregation shouldn’t appear merely because the renderer needs one value per category.&lt;/p&gt;

&lt;p&gt;That suggests a useful rule: let the model propose; let deterministic checks decide what is valid.&lt;/p&gt;

&lt;h2&gt;
  
  
  CSVs are deceptively complicated
&lt;/h2&gt;

&lt;p&gt;A column containing &lt;code&gt;00123&lt;/code&gt; might be an identifier, not a measurement. A date such as &lt;code&gt;04/05/2026&lt;/code&gt; isn’t unambiguous. Empty cells and zeroes aren’t interchangeable.&lt;/p&gt;

&lt;p&gt;These aren’t exotic cases. They’re ordinary business data.&lt;/p&gt;

&lt;p&gt;The engineering challenge is deciding when inference is safe and when the interface should ask the user. Too many questions make the tool tedious. Too few make it unreliable.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I’d like feedback on
&lt;/h2&gt;

&lt;p&gt;I’m especially interested in how other developers would expose uncertainty without overwhelming the UI.&lt;/p&gt;

&lt;p&gt;Would you show an inferred schema before generating anything? Ask only when confidence is low? Require confirmation for aggregation?&lt;/p&gt;

&lt;p&gt;Try &lt;a href="https://chartpetal.com/" rel="noopener noreferrer"&gt;ChartPetal&lt;/a&gt; with a non-sensitive table and tell me which assumptions you’d want a chart generator to make explicit.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>webdev</category>
      <category>discuss</category>
      <category>productivity</category>
    </item>
    <item>
      <title>I built a scientific figure generator around a review checkpoint</title>
      <dc:creator>ludy.dev</dc:creator>
      <pubDate>Sun, 18 Oct 2026 05:37:47 +0000</pubDate>
      <link>https://dev.to/lyyluca/i-built-a-scientific-figure-generator-around-a-review-checkpoint-3n12</link>
      <guid>https://dev.to/lyyluca/i-built-a-scientific-figure-generator-around-a-review-checkpoint-3n12</guid>
      <description>&lt;p&gt;I’m building &lt;a href="https://figuredraft.com/" rel="noopener noreferrer"&gt;FigureDraft&lt;/a&gt;, a web tool that turns research descriptions into scientific figure drafts.&lt;/p&gt;

&lt;p&gt;The visible workflow is short: describe the research, review objects, labels, and relationships, generate the figure, and download a PNG.&lt;/p&gt;

&lt;p&gt;The interesting engineering question is where to put the boundary between interpretation and rendering.&lt;/p&gt;

&lt;h2&gt;
  
  
  Treat interpretation as something users can inspect
&lt;/h2&gt;

&lt;p&gt;A direct prompt-to-image flow hides a lot inside one action. If the result is wrong, the user has to work backward from pixels to figure out whether the problem was the description, the interpretation, or the rendering.&lt;/p&gt;

&lt;p&gt;FigureDraft puts a review checkpoint in that flow.&lt;/p&gt;

&lt;p&gt;From an application-design perspective, that means thinking about two different things: the intended contents of the diagram and the image that represents them. Those shouldn’t be treated as interchangeable.&lt;/p&gt;

&lt;p&gt;Objects, labels, and relationships provide a useful vocabulary for that distinction.&lt;/p&gt;

&lt;h2&gt;
  
  
  The architecture matters more than a framework name
&lt;/h2&gt;

&lt;p&gt;I’m keeping this post focused on the workflow rather than publishing an unverified framework or model inventory. The implementation stack isn’t documented here, so I won’t dress this up as a reproducible backend tutorial.&lt;/p&gt;

&lt;p&gt;At the application level, though, the boundaries are worth discussing: research input, a reviewable interpretation, figure generation, and PNG delivery.&lt;/p&gt;

&lt;p&gt;Each boundary creates a question the interface needs to answer. What is the user reviewing? What information will generation use? What should happen if the description leaves a relationship ambiguous?&lt;/p&gt;

&lt;p&gt;These questions shape the product regardless of which frontend framework or model provider sits underneath it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I would test beyond the happy path
&lt;/h2&gt;

&lt;p&gt;For a workflow like this, a successful image download isn’t enough.&lt;/p&gt;

&lt;p&gt;I’d test descriptions with repeated object names, missing relationships, long labels, and conflicting directions. I’d also check whether the review screen makes omissions noticeable rather than simply making the interpretation look tidy.&lt;/p&gt;

&lt;p&gt;Those are product-level tests as much as technical ones.&lt;/p&gt;

&lt;h2&gt;
  
  
  Looking for developer feedback
&lt;/h2&gt;

&lt;p&gt;I’m especially interested in how other developers would represent uncertainty between interpretation and rendering.&lt;/p&gt;

&lt;p&gt;Would you surface ambiguous relationships individually? Ask the user a follow-up question? Keep the first version intentionally minimal?&lt;/p&gt;

&lt;p&gt;Try &lt;a href="https://figuredraft.com/" rel="noopener noreferrer"&gt;FigureDraft&lt;/a&gt; with a research description and tell me where the review boundary helps—or where it gets in your way.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>webdev</category>
      <category>sideprojects</category>
      <category>ux</category>
    </item>
    <item>
      <title>Building an AI Photo Enhancer Around a Verifiable Output</title>
      <dc:creator>ludy.dev</dc:creator>
      <pubDate>Tue, 22 Sep 2026 08:38:21 +0000</pubDate>
      <link>https://dev.to/lyyluca/building-an-ai-photo-enhancer-around-a-verifiable-output-14b2</link>
      <guid>https://dev.to/lyyluca/building-an-ai-photo-enhancer-around-a-verifiable-output-14b2</guid>
      <description>&lt;p&gt;I’m Ludy, and I built &lt;a href="https://uplenz.io/" rel="noopener noreferrer"&gt;Uplenz&lt;/a&gt;, a web utility for enhancing photos with AI, comparing details, and downloading a PNG.&lt;/p&gt;

&lt;p&gt;The product scope is intentionally small. The interesting engineering discussion isn’t "how many editing controls can fit on a page?" It’s "how do you help someone evaluate a generated result without hiding the constraints?"&lt;/p&gt;

&lt;h2&gt;
  
  
  Start with the processing contract
&lt;/h2&gt;

&lt;p&gt;At the product level, the flow is an input image, an AI enhancement operation, a comparison step, and a PNG download.&lt;/p&gt;

&lt;p&gt;That sounds simple, but each boundary deserves a clear contract. An accepted image isn’t the same as a completed edit. A completed edit isn’t the same as a successful download. And an unavailable processing slot shouldn’t look like a broken upload.&lt;/p&gt;

&lt;p&gt;Those distinctions are the foundation I’d use to review any implementation of this workflow.&lt;/p&gt;

&lt;h2&gt;
  
  
  Stack choices versus observable behavior
&lt;/h2&gt;

&lt;p&gt;The underlying framework, inference provider, hosting setup, and storage implementation aren’t detailed in this launch post. I don’t want to turn an architecture discussion into an invented stack diagram.&lt;/p&gt;

&lt;p&gt;What is observable is the browser-based workflow and the AI enhancement step. For a technical review, I’d separate image input, processing orchestration, result presentation, and export into distinct responsibilities, regardless of the specific libraries involved.&lt;/p&gt;

&lt;p&gt;That separation makes it easier to reason about failures without coupling every UI state to one long request.&lt;/p&gt;

&lt;h2&gt;
  
  
  No signup still needs resource boundaries
&lt;/h2&gt;

&lt;p&gt;Uplenz requires no signup and offers up to three shared free AI edits daily, subject to capacity.&lt;/p&gt;

&lt;p&gt;That makes capacity communication a core interface concern. "Free" doesn’t mean computation has no cost, and anonymous access doesn’t remove the need for resource controls.&lt;/p&gt;

&lt;p&gt;A useful design review would ask when availability is checked, how a failed attempt is explained, and whether the interface makes it obvious when someone should retry. Those are architectural questions as much as copywriting questions.&lt;/p&gt;

&lt;h2&gt;
  
  
  The output needs inspection
&lt;/h2&gt;

&lt;p&gt;AI enhancement can create convincing artifacts. A comparison experience should help users notice those changes rather than just celebrate a more dramatic image.&lt;/p&gt;

&lt;p&gt;I’m especially interested in feedback on comparing fine textures, evaluating faces, and making the download step unambiguous.&lt;/p&gt;

&lt;p&gt;Try &lt;a href="https://uplenz.io/" rel="noopener noreferrer"&gt;Uplenz&lt;/a&gt; with an image you know well. What would you inspect first, and what information would you need before trusting the result?&lt;/p&gt;

</description>
      <category>ai</category>
      <category>webdev</category>
      <category>ux</category>
      <category>discuss</category>
    </item>
    <item>
      <title>I built a lightweight aspect ratio calculator with vanilla JavaScript</title>
      <dc:creator>ludy.dev</dc:creator>
      <pubDate>Tue, 22 Sep 2026 07:23:17 +0000</pubDate>
      <link>https://dev.to/lyyluca/i-built-a-lightweight-aspect-ratio-calculator-with-vanilla-javascript-1pdh</link>
      <guid>https://dev.to/lyyluca/i-built-a-lightweight-aspect-ratio-calculator-with-vanilla-javascript-1pdh</guid>
      <description>&lt;p&gt;I built &lt;a href="https://aspectdock.com" rel="noopener noreferrer"&gt;AspectDock&lt;/a&gt; after repeatedly doing the same aspect-ratio calculations while working on images, video exports, and responsive layouts.&lt;/p&gt;

&lt;p&gt;The underlying math is straightforward, but building a useful interface around it raised a few interesting implementation questions.&lt;/p&gt;

&lt;h2&gt;
  
  
  Two Calculation Modes
&lt;/h2&gt;

&lt;p&gt;The first mode accepts a width and height, then calculates the ratio. To reduce the dimensions, the app finds the greatest common divisor of the two values and divides both by it. For example, 1920 × 1080 becomes 16:9 instead of a long decimal representation.&lt;/p&gt;

&lt;p&gt;The second mode starts with a selected ratio and one known dimension. The missing dimension is calculated using the ratio components. A 16:9 ratio with a width of 1280 produces a height of 720.&lt;/p&gt;

&lt;p&gt;Keeping these modes separate makes the input model easier to understand and avoids mixing incomplete values with stale results.&lt;/p&gt;

&lt;h2&gt;
  
  
  Handling Precision
&lt;/h2&gt;

&lt;p&gt;Pixel dimensions are usually integers, but ratio calculations can produce fractional values. The UI keeps the ratio calculation precise while presenting dimension results in a practical format. This matters when working with responsive containers or print dimensions where rounding can affect the final output.&lt;/p&gt;

&lt;p&gt;Validation also needs to cover empty fields, zero values, negative numbers, and incomplete input. A calculator should fail clearly rather than silently return misleading values.&lt;/p&gt;

&lt;h2&gt;
  
  
  Keeping the App Lightweight
&lt;/h2&gt;

&lt;p&gt;The current implementation is intentionally small: semantic HTML for the structure, CSS for the layout and responsive behavior, and client-side JavaScript for all calculations. No server request is required for the core experience, so results appear immediately and the tool remains useful even when the calculation itself is the only thing someone needs.&lt;/p&gt;

&lt;p&gt;Common ratios are treated as quick presets rather than hidden behind another menu. Copyable results are also important because the usual next step is pasting the value into a design brief, CSS file, or export dialog.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I Learned
&lt;/h2&gt;

&lt;p&gt;The hardest part was not the formula. It was deciding what information to show, when to show it, and how to make the interface feel predictable.&lt;/p&gt;

&lt;p&gt;You can try the finished version at &lt;a href="https://aspectdock.com" rel="noopener noreferrer"&gt;AspectDock&lt;/a&gt;. I would especially appreciate feedback on input validation, decimal handling, and whether the two-mode workflow feels natural.&lt;/p&gt;

</description>
      <category>javascript</category>
      <category>webdev</category>
      <category>css</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Building ErasePeople: The Hard Part Is Defining Who Disappears</title>
      <dc:creator>ludy.dev</dc:creator>
      <pubDate>Sun, 13 Sep 2026 15:44:09 +0000</pubDate>
      <link>https://dev.to/lyyluca/building-erasepeople-the-hard-part-is-defining-who-disappears-4gph</link>
      <guid>https://dev.to/lyyluca/building-erasepeople-the-hard-part-is-defining-who-disappears-4gph</guid>
      <description>&lt;p&gt;This is an architectural model, not a disclosure of ErasePeople’s internal implementation.&lt;/p&gt;

&lt;p&gt;At each boundary, there’s a different class of problem. Image orientation can affect coordinates. Selection can become ambiguous when people overlap. Reconstruction can introduce artifacts. Export can accidentally diverge from what the preview showed.&lt;/p&gt;

&lt;p&gt;Keeping those concerns separate makes the system easier to reason about than treating the entire operation as one opaque "edit" button.&lt;/p&gt;

&lt;h2&gt;
  
  
  Stack transparency matters
&lt;/h2&gt;

&lt;p&gt;The public product information describes an AI photo-removal website, not its framework, model provider, storage layer, or deployment platform. I’m keeping those implementation details out of this post rather than presenting an invented stack as a build log.&lt;/p&gt;

&lt;p&gt;For anyone implementing a similar application, I’d evaluate the stack around image handling, asynchronous processing, error recovery, and clear data-retention behavior. Those requirements matter more than choosing a fashionable frontend.&lt;/p&gt;

&lt;h2&gt;
  
  
  Comparison is part of correctness
&lt;/h2&gt;

&lt;p&gt;A technically successful response can still be a bad edit.&lt;/p&gt;

&lt;p&gt;The comparison step gives users a way to inspect whether the intended person disappeared and whether important surroundings remained plausible. That makes it part of the product’s quality loop, not just a presentation feature.&lt;/p&gt;

&lt;p&gt;I’d like feedback from developers working on image interfaces: how would you express ambiguous "background people" intent without making the user complete a complicated selection workflow? You can try the current experience at &lt;a href="https://erasepeople.com/" rel="noopener noreferrer"&gt;ErasePeople&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>webdev</category>
      <category>ux</category>
      <category>discuss</category>
    </item>
    <item>
      <title>How I built a lightning-fast, ad-free web novel reader using Next.js and Cloudflare</title>
      <dc:creator>ludy.dev</dc:creator>
      <pubDate>Fri, 07 Aug 2026 18:38:02 +0000</pubDate>
      <link>https://dev.to/lyyluca/how-i-built-a-lightning-fast-ad-free-web-novel-reader-using-nextjs-and-cloudflare-5dch</link>
      <guid>https://dev.to/lyyluca/how-i-built-a-lightning-fast-ad-free-web-novel-reader-using-nextjs-and-cloudflare-5dch</guid>
      <description>&lt;p&gt;Reading web novels online is a notoriously laggy experience. Most aggregator sites are packed with heavy tracking scripts, bloated ad networks, and redirects that make mobile reading painful. I wanted to see if I could build a platform that serves thousands of chapters with sub-second page loads.&lt;/p&gt;

&lt;p&gt;That is why I created &lt;a href="https://mubooks.com/" rel="noopener noreferrer"&gt;MuBooks&lt;/a&gt;. &lt;/p&gt;

&lt;p&gt;To achieve maximum performance, I built the frontend using Next.js. The reading interface relies heavily on static generation where possible, combined with server-side rendering for newly updated chapters. I offloaded the heavy lifting to Cloudflare Workers to cache the parsed, sanitized chapter content at the edge. By removing the tracking scripts, ads, and heavy assets, the payload size for a standard chapter is under 50KB, resulting in instantaneous page transitions.&lt;/p&gt;

&lt;p&gt;One of the biggest technical challenges was processing the raw chapter feeds. The source files often contain inconsistent HTML formatting, broken tags, and inline styles. I built a custom parser pipeline that strips out all non-essential HTML, sanitizes the text to prevent XSS, and normalizes the structure into clean, responsive Markdown-style components.&lt;/p&gt;

&lt;p&gt;For the client side, I built a highly responsive reader component. Using lightweight Tailwind classes and local storage, users can toggle dark mode, adjust font scaling, and change line heights. The state is saved locally, meaning the user can resume reading exactly where they left off without needing an external database call.&lt;/p&gt;

&lt;p&gt;By keeping the architecture lightweight and caching aggressively at the edge, the hosting costs remain minimal while providing a premium, native-app-like experience for readers.&lt;/p&gt;

</description>
      <category>nextjs</category>
      <category>webdev</category>
      <category>javascript</category>
      <category>serverless</category>
    </item>
  </channel>
</rss>
