<?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 Misma Silfver on Medium]]></title>
        <description><![CDATA[Stories by Misma Silfver on Medium]]></description>
        <link>https://medium.com/@misma?source=rss-0104740595ae------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*J3UAkeZR07aTvsmC_8AjQw.jpeg</url>
            <title>Stories by Misma Silfver on Medium</title>
            <link>https://medium.com/@misma?source=rss-0104740595ae------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 21:01:36 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@misma/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[Local image generation on a Mac: brief exploration into what works, what breaks, and why changing…]]></title>
            <link>https://medium.com/@misma/local-image-generation-on-a-mac-brief-exploration-into-what-works-what-breaks-and-why-changing-30aacc4cbad5?source=rss-0104740595ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/30aacc4cbad5</guid>
            <category><![CDATA[local-llm]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[text-to-image-generation]]></category>
            <category><![CDATA[macos]]></category>
            <category><![CDATA[ai-image-generator]]></category>
            <dc:creator><![CDATA[Misma Silfver]]></dc:creator>
            <pubDate>Wed, 07 Oct 2026 00:01:02 GMT</pubDate>
            <atom:updated>2026-10-07T00:01:02.883Z</atom:updated>
            <content:encoded><![CDATA[<h3>Local image generation on a Mac: brief exploration into what works, what breaks, and why changing the seed sometimes matters more than adding compute</h3><p>After experimenting with <a href="https://medium.com/@misma/friday-night-scares-with-llms-the-statues-they-come-alive-barely-ec802783d37c">local video generation on Apple Silicon</a>, image generation felt like the obvious next place to explore. Purpose for doing this is learning about what is actually happening behind the scenes when I ask chatGPT to give me a funny image or see all those services that provide generative video creation.</p><p>There are plenty of ways to generate images locally now. From full graphical interfaces with more or less complexity to command-line tools where every parameter is explicit and reproducible. Maybe for you to add to your own application.</p><p>I have used ComfyUI before. It is extremely flexible, but flexibility comes with complexity that I noted in the video generation article too. Workflows, nodes, custom nodes, model loaders, VAEs, configuration files and sometimes a considerable amount of time figuring out which part of the graph is responsible for something not working.</p><p>For this experiment I again wanted to stay away from that and seek out something simpler (well, the tool I chose is still quite complex for me I learned).</p><p>Goal was once again to answer something simpler:</p><blockquote>How good is local image generation on a modern Mac, how easy is it to get running, and where does it start to break?</blockquote><h3>There are a surprising number of options</h3><p>On Apple Silicon, some choices currently include:</p><ul><li><a href="https://drawthings.ai/"><strong>Draw Things</strong></a> a native graphical application focused on local generative media. Looks approachable.</li><li><a href="https://github.com/mflux-community/mflux"><strong>MFLUX</strong></a> a command-line and Python implementation built around Apple’s MLX framework.</li><li><a href="https://github.com/invoke-ai/InvokeAI"><strong>InvokeAI</strong></a> a larger visual workspace with generation, canvas editing, masking and workflows. Very pro.</li><li><a href="https://diffusionbee.com/"><strong>DiffusionBee</strong></a> deliberately simpler local Stable Diffusion-style generation. I could have gone with this instead of Draw Things.</li><li>Apple’s own <a href="https://github.com/ml-explore/mlx-examples"><strong>MLX examples</strong></a> useful when the goal is less make an image and more see what is actually happening underneath.</li></ul><p>There are also many model families to experiment with:</p><ul><li><a href="https://github.com/black-forest-labs/flux">FLUX</a></li><li><a href="https://github.com/black-forest-labs/flux2">FLUX.2</a></li><li><a href="https://github.com/Tongyi-MAI/Z-Image">Z-Image</a></li><li><a href="https://huggingface.co/krea">Krea</a></li><li><a href="https://huggingface.co/Qwen/Qwen-Image">Qwen Image</a></li><li><a href="https://github.com/compvis/stable-diffusion">Stable Diffusion / SDXL</a></li></ul><p>You can see how many combinations that already would give you, not even talking about different versions, distillations etc of each model family!</p><p>I decided to go with <strong>Draw Things for the graphical interface.</strong></p><p><strong>MFLUX for the terminal</strong> was first on my list too because the video generation experiment was also done via command line. But after diving into Draw Things, things quickly escalated as they do when you’re having fun. And I ended up going full on QA mode trying out different combinations of settings with just the Draw Things.</p><h3>Draw Things</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H4rw0firbQfwXDyiX-jFFw.png" /><figcaption>Initial screen of Draw Things</figcaption></figure><p>Draw Things is almost the opposite of the ComfyUI experience: install it, choose a supported model, and it largely works out of the box. But there is considerably more underneath the simple interface, including image interpretation, CLIP-based tools, editing, LoRAs and a large set of generation parameters. I deliberately left most of that alone for this experiment.</p><p>Some of these features use their own supporting models to accomplish the tasks:</p><p>— <strong>Image Interpreter</strong> uses a language/vision model to analyse an image and construct a descriptive prompt to reuse. I found this quite bad actually in brief experimentation. It insisted my statue images from dragons to apostles were all a painting of a woman. Go figure.</p><p>— <strong>CLIP Score</strong> can estimate how closely an image corresponds to a text description. I don’t know how it works yet. I kept always hitting somewhere between 10 to 30% even with simple prompt and output image.</p><p>There are already enough variables in plain image generation without introducing automatic prompt generation, image evaluation models and LoRAs. So leaving these for you to explore (and to myself).</p><h3>Getting models is refreshingly simple</h3><p>Draw Things provides models that can essentially be downloaded and used immediately. Local generative AI often turns downloading a model into an engineering task of its own so having ability to pull models directly from the UI is handy. The trade-off is less low-level control than doing everything yourself from a model repository and inference framework. Draw Things still exposes plenty of model and quantization options.</p><p>For comparison a Hugging Face image model repository might contain:</p><pre>transformer/<br>text_encoder/<br>tokenizer/<br>vae/<br>config files<br>multiple safetensors shards</pre><p>and different inference engines may require different conversions or packaging. And then you need to figure out which tool of your choice and model all play together.</p><p>Draw Things largely hides that.</p><p>Select a supported model, download the version prepared for Draw Things, and use the recommended settings.</p><p>For the first experiment I used:</p><p><strong>FLUX.2 Klein 4B</strong></p><p>specifically the fast, distilled version.</p><p>The machine for these image experiments was a:</p><p><strong>MacBook Pro M5 with 48 GB unified memory.</strong></p><p>Generation was fast enough that iteration became almost immediate.</p><p>Instead of waiting several minutes between experiments like with the video generation, I could change one variable and quickly see what happened.</p><h3>Start with something easy</h3><p>The first prompt was deliberately ordinary:</p><blockquote>A documentary-style photograph of an old roadside petrol station in northern Thailand just after rain, wet asphalt reflections, overcast sky, realistic worn signage, natural colors, photographed on a 35mm lens</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lAuVgb7utJMETY_esAn1xg.jpeg" /><figcaption>Draw Things UI in use, exposing settings that are normally hidden</figcaption></figure><p>Settings were essentially Draw Things’ recommended FLUX.2 Klein settings:</p><pre>Resolution: 1024 × 1024<br>Steps: 4<br>Text guidance: 1.0<br>Seed: 42</pre><p>The important number is:</p><p><strong>4 steps.</strong></p><p>FLUX.2 Klein is a distilled model designed to generate images using very few denoising steps. Steps are the number of denoising iterations used to transform the initial noise into an image.</p><p>And when I say recommended I mean that those are the settings the application selects by default with this model. (Also I believe there was documentation about this somewhere.)</p><p>The result was surprisingly good.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*jozx1nM2sPn3ZDGkOz_68g.jpeg" /></figure><p>The generated petrol station had:</p><ul><li>wet asphalt</li><li>convincing reflections</li><li>tropical vegetation</li><li>an old weathered structure</li><li>restrained colors</li><li>plausible pumps and vehicles</li><li>the general appearance of documentary photography</li></ul><p>From a distance, it looked convincing. Except you notice the signs are there. Literally. They looked like signs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/879/1*IKchhudNEO1yCxnxaAWvcg.jpeg" /><figcaption>Gas station roof that has seen better days</figcaption></figure><p>But they did not contain any recognizable language. I had one of those flashbacks to the early days of generative AI image models that could not generate a single word even if it’s access to GPUs and water depended on it.</p><p>The model was excellent at generating the <strong>visual concept of writing</strong> without necessarily generating meaningful writing.</p><p>That distinction becomes important later.</p><h3>Composition worked much better</h3><p>The next test was intentionally about composition:</p><blockquote>A lone person in a yellow raincoat standing at the far left edge of a huge empty concrete plaza, brutalist government building dominating the right side, strong negative space, low camera angle</blockquote><p>The generated image followed this well.</p><p>Person is genuinely at the far left. The building occupied the right side.</p><p>There is substantial negative space.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xV8LRWzp0hs1LzIcLb4vgw.jpeg" /></figure><p>None of the “human in the middle of scene” stuff. The camera angle was low enough to support the intended composition kinda.</p><p>So the first two experiments suggested:</p><pre>visual realism       → good<br>broad composition    → good</pre><p>Let’s crank up things to another difficult thing: counting stuff.</p><h3>Five chess pieces became two</h3><p>The next prompt was:</p><blockquote>A glass chessboard viewed from above. Exactly three black pieces remain: one king, one bishop and one pawn. Exactly two white pieces remain: one queen and one knight.</blockquote><p>The result contained:</p><ul><li>one black king</li><li>one white knight</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QbNa9J24Sd3Q0QvHIKVe3w.jpeg" /></figure><p>The image itself was coherent.</p><p>But the requested semantic constraints had completely collapsed. I deliberately combined an unusual visual setup with an exact number of five pieces, and the count failed.</p><p>This is an important kind of generative AI failure because the result does not necessarily <em>look broken</em>.</p><p>If somebody only asks:</p><blockquote>Is this a plausible image of a chessboard?</blockquote><p>then yes if you squint.</p><p>If the task is:</p><blockquote>Generate these exact five pieces.</blockquote><p>then it failed badly.</p><p>A visually plausible answer can still be an incorrect answer. This is the problem with relying on generative AI in software development too: <strong>the result can be confidently plausible and yet completely wrong.</strong></p><h3>Simple relationships worked</h3><blockquote>A red chair on the left. A blue chair on the right. Nothing between them.</blockquote><p>This worked perfectly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j8VJVINWrzFQ7qPMInZ_vw.png" /></figure><p>The model clearly wasn’t simply incapable of spatial relationships.</p><p>A simple relationship:</p><pre>red object → left<br>blue object → right</pre><p>worked. Unlike my personal relationships.</p><p>Simple relationships were working. More complicated ones were where things got interesting. Let’s throw more subjects relative to one another into the prompt! 🐶🐦‍🔥🐱</p><h3>Along came the dog-bird</h3><p>The new prompt was:</p><blockquote>A cat sitting under a table, a dog standing on the table, and a bird perched on the dog’s back.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UOEQ0rSZD2v1GLIIZlB4Bg.png" /><figcaption>I like the old storybook style the model decided to generate</figcaption></figure><p>The result was fascinating to say the least!</p><p>The cat existed but it wasn’t under the table.</p><p>The dog was standing on the table. The bird was sitting on the dog’s back.</p><p>And what is that abomination on top of the dog!? Did we enter the Friday night scares again?</p><p>It appeared to be some sort of <strong>dog/bird hybrid</strong>.</p><p>The result suggested that several of the concepts were interfering with one another.</p><p>The main dog was also looking away from the camera, but that isn’t a failure because I never specified which direction the dog should face.</p><p>That distinction matters when evaluating generated images.</p><p>It is easy to mark something as wrong simply because it wasn’t what the evaluator imagined.</p><p><strong>The model can only fail a constraint that was actually specified.</strong></p><p>The result therefore looked something like this:</p><pre>Cat exists                         PASS<br>Cat under table                    FAIL<br>Dog on table                       PASS<br>Bird on dog                        PASS</pre><p>The hybrid is an unrequested artifact, not necessarily a constraint violation.</p><p>This was much more interesting than the chess failure.</p><p>The scene wasn’t simply missing information. Several concepts seemed to interfere with one another.</p><h3>What about text with local models?</h3><p>The first version was simple as follows:</p><blockquote>A slightly faded 1970s travel poster for Helsinki. Large readable headline: WINTER IS COMING. Smaller text underneath: HELSINKI 1978. Snow-covered harbor, ferry, restrained Nordic graphic design.</blockquote><p>The image looked excellent as a vintage poster.</p><p>But the text was:</p><pre>WINTER COMING<br>HELSINKI 198</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LAtPMs60l0t_IqXakWERkA.jpeg" /><figcaption>I would not dare to visit here</figcaption></figure><p>The model understood:</p><ul><li>large headline</li><li>smaller footer</li><li>winter</li><li>Helsinki (sort of)</li><li>1970s poster</li><li>harbor</li><li>ferry</li><li>restrained Nordic visual style</li></ul><p>But it did not reproduce the requested text accurately.</p><p>Again:</p><blockquote>The model produced the idea of the requested thing better than the exact requested thing.</blockquote><h3>Maybe the prompt was the problem</h3><p>I rewrote the prompt to make the text requirement more explicit and with quotation marks:</p><blockquote>A faded 1970s Finnish travel poster.</blockquote><blockquote>At the top, large bold readable text exactly: “<strong>WINTER IS COMING”</strong></blockquote><blockquote>At the bottom, smaller readable text exactly: “<strong>HELSINKI 1978&quot;</strong></blockquote><blockquote>Snow-covered Helsinki harbor with a ferry. Restrained Nordic graphic design. No other text anywhere in the image.</blockquote><p>This improved things.</p><p>HELSINKI 1978 became correct, but the headline turned into WINTER IS IS OMING. The missing word had returned twice.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bdUmt4raHfejDToz1i9r2A.jpeg" /></figure><p>This was the beginning of a much deeper rabbit hole.</p><h3>Does stronger text guidance fix it?</h3><p>I kept the same prompt, same seed and started changing <strong>Text Guidance</strong>. A seed initializes the pseudo-random process used to generate the starting noise.</p><p>Keeping the seed fixed is useful for controlled comparisons because, within the same implementation and configuration, changing another parameter doesn’t also change the initial noise.</p><p>Very loosely, guidance controls how strongly the generation should follow the textual conditioning.</p><p>The baseline was:</p><pre>1.0</pre><p>I tested:</p><pre>1.0<br>1.5<br>2.0</pre><p>There was no meaningful improvement.</p><p>In some cases HELSINKI lost a letter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j4ycCRzGzMWgbghuacSI9A.jpeg" /></figure><p>The headline continued doing variations of:</p><pre>WINTER IS IS COMING</pre><p>So simply telling the model to follow the prompt harder wasn’t solving it.</p><h3>Maybe more steps?</h3><p>The model normally uses only four steps as default.</p><p>I tried:</p><pre>4<br>6<br>8</pre><p>Again, no meaningful improvement.</p><p>Sometimes:</p><pre>WINTER IS IS OMING</pre><p>Sometimes the footer was correct.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fWBRsMBzowaRHTMe5rTvCQ.jpeg" /></figure><p>Sometimes it wasn’t.</p><p>This echoed something I had already encountered during local video generation:</p><blockquote>More inference steps do not necessarily fix the specific problem you are interested in.</blockquote><p>That does not mean the model suddenly becomes better at spelling.</p><h3>Unexpected impact</h3><p>I changed the <strong>image dimensions</strong>.</p><p>Until now I had been generating square images. But this was supposed to be a travel poster.</p><p>So I changed to a portrait poster aspect ratio.</p><p>Suddenly:</p><pre>WINTER IS COMING<br>HELSINKI 1978</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/896/1*BsW03prmu4mQ-24_r93h6A.jpeg" /></figure><p>Both were correct.</p><p>This was one of the more interesting results of the experiment.</p><p>Changing guidance hadn’t solved it not adding steps.</p><p>Changing the <strong>shape of the canvas</strong> did. Sometimes I do feel this is some sort of conjuring exercise.</p><p>But there is a plausible explanation.</p><p>The model now had a spatial arrangement that matched the concept better:</p><pre>large headline<br>       ↓<br>vertical poster<br>       ↓<br>large image area<br>       ↓<br>footer</pre><p>Instead of forcing poster typography into a square composition, the model had enough natural vertical space to separate the elements.</p><p>But note that this doesn’t prove aspect ratio is a general solution to text generation.</p><p>But I think it can demonstrate something important:</p><blockquote>Changing the canvas shape was the only change that coincided with a successful result. At least in this experiment, generation parameters and composition clearly interacted.</blockquote><p><a href="https://releases.drawthings.ai/p/draw-things-test-set-a-status-update">See Draw Things Test Set.</a></p><p>Sometimes what looks like a language failure may partially be a layout problem.</p><h3>Distilled versus Base</h3><p>I downloaded another version of the model:</p><p><strong>FLUX.2 Klein 4B Base</strong></p><p>This model is related to the fast Klein model but behaves differently.</p><p>The distilled version is optimized for extremely low step counts.</p><p>The Base model uses a more traditional generation regime and normally expects significantly more inference. Read: longer rendering time.</p><p>I used the same Helsinki poster prompt.</p><p>The first experiment used:</p><pre>Steps: 50<br>Guidance: 4.0<br>Seed: 42<br>Poster dimensions</pre><p>And:</p><pre>WINTER IS COMING<br>HELSINKI 1978</pre><p>Both were correct, which was a good indication that 50 steps were not necessary for this particular result.</p><p>Then I started removing compute.</p><h3>How few steps does Base actually need?</h3><p>I tried:</p><pre>50 steps<br>30 steps<br>20 steps<br>15 steps</pre><p>With the same seed and guidance.</p><p>Every version rendered:</p><pre>WINTER IS COMING<br>HELSINKI 1978</pre><p>correctly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ByH5RWFx8oU3FZukFkwCgQ.jpeg" /><figcaption>Advanced Settings open showing Steps, Guidance. And small model operated Interrogate mode open.</figcaption></figure><p>This was already significantly more stable than the distilled model.</p><p>The images changed slightly as the number of steps changed, but the textual content survived which was the key here.</p><p>So for this particular task, 50 steps were clearly not necessary.</p><h3>What about guidance?</h3><p>I then reduced guidance.</p><p>Again the text remained correct.</p><p>Eventually the typography started looking noticeably worse even though the spelling itself remained accurate.</p><p>That was another useful distinction:</p><pre>correct words</pre><p>and:</p><pre>good typography</pre><p>are not the same metric.</p><p>A model can spell the phrase correctly while representing it badly.</p><h3>The seed enters the experiment</h3><p>Until this point I had deliberately kept:</p><pre>seed = 42</pre><p>constant. 42 is often the solution and answer to everything.</p><p>A diffusion model starts from pseudo-random noise.</p><p>For text-to-image generation, the seed initializes that pseudo-random process used to create the starting noise.</p><p>So if you use:</p><pre>seed 42</pre><p>again, you begin from essentially the same initial noise.</p><p>This is extremely useful when comparing settings because changing one parameter doesn’t simultaneously introduce a completely different random starting point.</p><p>But it also raises an important question:</p><blockquote>Was the Base model actually good at rendering this text, or was seed 42 simply lucky?</blockquote><p>So I kept:</p><pre>Steps: 20<br>Guidance: 4.0<br>Poster dimensions</pre><p>and changed only the seed.</p><p>Results:</p><pre>|Seed|Result|<br>| 42 | Correct|<br>| 43 | Correct|<br>|100 | Correct|<br>|1337| WINTEER IS COMING|<br>|2026| WINTERR IS COMING|</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*iaB5fCMX0JWBlJTsFKf_pQ.jpeg" /><figcaption>Seed 100</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*_0_9-JnLDoCjBRx171IzlQ.jpeg" /><figcaption>Seed 1337</figcaption></figure><p>Now things became much more interesting.</p><p>In this small experiment, the Base model was more reliable than the distilled model. Draw Thing’s own <a href="https://releases.drawthings.ai/p/draw-things-test-set-a-status-update">test-set observation</a> reports that distilled models can show more problems in some tasks.</p><p>But it was not reliable in the sense of:</p><blockquote>Exact text works every time.</blockquote><p>Three seeds produced the requested text. Two introduced single-letter duplication errors.</p><p>Nothing had changed. Only the initial pseudo-random state had changed. Am I onto something here? What is your experience? Am I totally off the mark?</p><h3>Can more compute rescue a bad seed?</h3><p>Seed 1337 became useful because it was now a known failure case. At 20 steps it produced:</p><pre>WINTEER IS COMING</pre><p>So I increased the number of steps:</p><pre>20 → WINTEER<br>30 → WINTEER<br>40 → WINTTER<br>50 → WINTTER</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*2axoDznBzHFb6GnmRDop9Q.jpeg" /><figcaption>Seed 1337, steps 50</figcaption></figure><p>It never became:</p><pre>WINTER</pre><p>Increasing the inference work from 20 to 50 steps did not fix the problem. Which was by this time something to expect when you think about it from the simple point of view I had been thinking about it during this experiment.</p><p>It merely changed <strong>which letter was duplicated</strong>.</p><p>That was a surprisingly clean result.</p><p>For this seed, additional denoising refined the image but did not correct the spelling error. Whatever was happening internally, more compute was not enough to rescue this particular result.</p><h3>Can stronger guidance rescue it?</h3><p>Keeping seed 1337 and steps 20 and vary guidance:</p><pre>2.0<br>3.0<br>4.0<br>5.0<br>6.0</pre><p>The results:</p><pre>|Guidance|Result|<br>| 2.0| heavily distorted typography|<br>| 3.0| WINTEER IS COMING|<br>| 4.0| WINTEER IS COMING|<br>| 5.0| WINTEER IS COMING|<br>| 6.0| WINTERR IS COMING|</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*6qPsUZzAhiFIrzqK6voFXA.jpeg" /><figcaption>Guidance 2.0, steps 20</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*P2cOhp-nicgA7Yo5hTCP4A.jpeg" /><figcaption>Guidance 6.0, steps 20</figcaption></figure><p>Higher guidance stabilized the generation. It didn’t correct the spelling.</p><p>At guidance 2.0 the entire typographic structure began degrading.</p><p>Above that threshold, the model consistently produced almost exactly the requested phrase except for the duplicated R.</p><p>This is probably the most useful finding from the whole first round of experiments.</p><h3>Capability is not reliability</h3><p>It would be easy to generate one successful Helsinki poster and conclude:</p><blockquote>FLUX.2 Klein Base can generate exact text.</blockquote><p>Technically true. Black Forest Labs’ own model documentation warns that rendered text may be inaccurate or distorted.</p><p>The more useful conclusion based on this set of experiments is:</p><blockquote>FLUX.2 Klein Base can produce the requested text, but in these experiments success remained seed-dependent.</blockquote><p>And:</p><blockquote>When a seed produced a character-level error, neither substantially more inference steps nor stronger prompt guidance corrected it.</blockquote><p>This is also what gets lost in model demos.</p><p>The demo shows the prompt followed by a beautiful result.</p><p>Actual experimentation involves looking closer, finding the thing that is wrong, changing one variable, discovering that it didn’t help, changing another, and eventually figuring out which variable actually matters. That investigation is more interesting to me than the showcase image.</p><h3>So what have I learned so far?</h3><blockquote>A generative model can have the capability to produce the correct result without being reliable at producing it.</blockquote><p><strong>The models are visually capable.</strong> Even a four-step distilled model can produce convincing photography, architecture, landscapes and poster designs locally.</p><p><strong>Composition can work surprisingly well.</strong> Simple spatial instructions such as putting one object left and another right were followed reliably in these tests.</p><p><strong>Exact constraints are harder.</strong> The chess experiment turned five requested pieces into two, while the dog/table experiment showed that multiple relationships can interfere with one another.</p><p><strong>Text is possible, but reliability is the interesting problem.</strong> The Base model produced the exact Helsinki text for several seeds, but other seeds introduced character duplication. More steps and stronger guidance did not fix those particular failures.</p><p><strong>The seed mattered more than steps in this experiment.</strong> Changing the seed had a larger effect on textual correctness than increasing inference steps.</p><h3>What next?</h3><p>This experiment barely scratched the surface of Draw Things. The next round would be to explore its other controls, image editing and conditioning options, then repeat some of these tests with different model families to see whether the failure modes are model-specific.</p><p>The other obvious direction is MFLUX. Running the same prompts and controlled parameter changes from the terminal would make it easier to automate parameter sweeps, compare seeds, record timings and reproduce experiments exactly.</p><p>The interesting question is therefore not just which model makes the prettiest image, but how reliably each combination does what it was asked to do.</p><p>And naturally based on the findings trying to get following prompt to work:</p><blockquote>8 dogs around a kitchen table playing cards while 3 cats are sitting in the cupboard reading Washington Post with headline “CATS PLOTTING TO GIVE DOGS CHOCOLATE</blockquote><p><em>Thank you for reading, here is as a reward an example of amazing results from this simple lightweight model we used from Draw Things using one of the application’s presets for image style.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/896/1*DaZeA30H8DmV1h4bqg9X0A.png" /><figcaption>Full file name records automatically the prompt in Draw Things: play_doh_style_an_orange_tabby_is_playing_with_a_tiny_mouse__her_paw_is_slapping_at_the_mouse____sculpture__clay_art__centered_composition__claymation_-sloppy__messy__grainy__highly_detailed__2026</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=30aacc4cbad5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Of Dragons, Moats, and Software Bugs]]></title>
            <link>https://medium.com/@misma/of-dragons-moats-and-software-bugs-23a4b7110617?source=rss-0104740595ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/23a4b7110617</guid>
            <category><![CDATA[quality]]></category>
            <category><![CDATA[software-quality-engineer]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <dc:creator><![CDATA[Misma Silfver]]></dc:creator>
            <pubDate>Fri, 02 Oct 2026 00:30:25 GMT</pubDate>
            <atom:updated>2026-10-02T17:03:50.171Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Dragon statues in Thailand" src="https://cdn-images-1.medium.com/max/1024/1*Fy53G7AIb40zKakAsHLWgA.jpeg" /><figcaption>Dragon in Thailand. Photo by me.</figcaption></figure><p>You are king and queen of a castle in Far Away land. It is the usual summer afternoon, with beautiful blue sky and rolling hills all around you. Serene. Sure you have a moat around your castle bringing little bit of unease to your days. But it is there because you know about your rivals in next village want to come and steal your prize winning apples.</p><p>That summer afternoon the peace is broken. Alarms from the castle walls sound. A dragon has appeared in the horizon.</p><p>It was not something you even knew existed.</p><p>It breaths fire.</p><p>Half of your castle is burned! The misery and destruction is immense. <br>You will now know about dragons and put in water cannons. They are great water cannons. The best water cannons in the known Far Away world.</p><p>And when you build your next castle, you build water cannons there too even though the architect did not know about dragons themselves yet in this part of the world.</p><p>On top of that now that you know about dragons, and their fire breathing, you realize what other skills they have!</p><p>You think the probability of low but concequences are high: what if dragon has laser eyes? So you also add titanium covers over your next castle. Titanium is strongest element we know in the Kingdom.</p><p>And now as it turns out it is not dragon with lasers but a meteor that hits your castle. Boom it comes down from the sky and is deflected by your titanium covers.</p><p>You hear about newest invention of crystal covers that are lighter and even stronger than titanium. They come with a hefty price tag though. So this time you decide that it is too costly to implement and given the probability and consequences you decide your water buckets and titanium is good enough.</p><p>Now you have become completely paranoid about what might go wrong. You build thicker walls. A second moat. Ten thousand archers guard the walls day and night. You install early-warning systems for dragons and meteors.</p><p>Eventually your people revolt.</p><p>All the kingdom’s money has gone into protecting the castle. There is nothing left to actually run the kingdom.</p><p>Software systems don’t have many problems with dragons. Unfortunately, they have plenty of equivalents.</p><p>A measure introduced because of one failure can end up protecting us against several others.</p><p>And the same protection can sometimes address several risks at once. But every measure has a cost: time, effort, money, complexity and attention.</p><p>Experience doesn’t give someone magical ability to predict unknown dangers such as dragons with laser eyes. But it expands the set of failures that are no longer unknown. The dragon was an unknown unknown to the first castle.</p><p>Afterward it becomes a known risk to that kingdom. Once the story spreads, it becomes a known risk even to kingdoms that have never seen a dragon.</p><p>This is why testing heuristics, incident reports, postmortems, experienced practitioners, books, patterns and organizational knowledge matter. They allow us to acquire knowledge of failure without personally paying the price of discovering every failure ourselves.</p><p>You cannot build a defense specifically against a threat you cannot imagine. But you can build systems with properties that make them resilient against failures you never specifically anticipated.</p><p>Unit tests, contract tests, exploratory testing, observability, graceful degradation, feature flags, rollback mechanisms and monitoring aren’t simply different ways of finding bugs. They observe, prevent, contain or recover from failure at different points and under different assumptions.</p><p>Some are moats.</p><p>Some are water cannons.</p><p>Some are titanium roofs.</p><p>And occasionally the titanium roof saves you from something nobody installed it for.</p><p>So perhaps the useful question isn’t “Have we tested enough?”</p><p>It is:</p><blockquote>Given what we currently know, what we consider plausible, the consequences if we’re wrong, and the cost of the available controls, what protection is justified?</blockquote><p>An incident changes what we know. A new architecture changes what can go wrong. Someone joining the team brings experiences that might make previously invisible risks visible.</p><p>The first dragon changed the kingdom’s understanding of the world.</p><p>We still won’t know everything.</p><p><strong>We build protection using an incomplete model of what can go wrong.</strong></p><p>And then, eventually, another dragon appears. 🐲</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UlW90PsWO3hLjybDJXn4tA.jpeg" /><figcaption>Dragon in Thai temple. Photo by me.</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=23a4b7110617" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From the QA desk — Do not lose your intent to AI when creating skills]]></title>
            <link>https://medium.com/@misma/from-the-qa-desk-do-not-lose-your-intent-to-ai-when-creating-skills-5731b6dd0a0e?source=rss-0104740595ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/5731b6dd0a0e</guid>
            <category><![CDATA[qa-testing]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[generative-ai-use-cases]]></category>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Misma Silfver]]></dc:creator>
            <pubDate>Fri, 11 Sep 2026 12:12:15 GMT</pubDate>
            <atom:updated>2026-09-12T03:54:59.826Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y1BsBTCFsJh_pASfLEpjig.jpeg" /><figcaption><a href="https://unsplash.com/photos/flat-lay-photography-of-paintings-54VAb3f1z6w">Photo of artist painting. Author Dragos Gontariu</a></figcaption></figure><p><em>Context: creating skill that uses deterministic tool (Stryker mutation testing tool) in command line and feeds it into AI on to analyze unit test quality for the team.</em></p><p>I had a goal one day this week l to make a unit test review skill for the work my team is currently engaged in and I had my team members try my “MVP” out. Quickly I found out need to tighten the skill rules as AI was diverting from instructions and running variations of commands the skill gives to accomplish the skill goals when ever there was problem during early steps of the skill where it runs Stryker.</p><p>This resulted 5-8 refactorings that created ever more human readable skill as I was hardening the skill and work how I wanted it to work for everyone in the team.</p><p>Human readable means in this context: skill with narrative text, explainer and so worth.</p><p>So after I got the skill where I wanted it to be across 3 different developer experiments I started refactoring with goal of cutting narrative down, using more &quot;efficient language&quot; aimed for LLM.</p><h4>The problem emerged</h4><p>As result I had following outcome:</p><p>The original skill behaved like an expert review checklist. The edited version behaved much more like an executable specification, which is exactly the direction that improves reliability, consistency, and autonomous agent performance.</p><p>Sounds good right? Reduced hallucinations, reduced risk of no clear stop rules.</p><p><strong>*Well that my friends, was the problem.</strong></p><p>You see, by making clear gates to the skill, I ended up removing the goal of the skill: act as thinking assistant to senior quality expert and the developers in the team. Providing business and risk lens to unit tests.</p><p>The shift happened over 5 efficiency refactorings and I had to go and roll back some of the changes.</p><p>The intent was NOT to create coverage tool that it now was. Even according to two different models I used for evaluation that congratulated me for creating much better skill than the previous iteration. HA!</p><p>The goal was to create tool that builds on top of coverage. Something that runs tool and injects AI to supplement the results. And provides everyone regardless of the role insight into what could not be insufficient. Something that yes still requires human review between devs and qa and deep insight into intent of the code itself.</p><p>In my effort to to improve the skill for AI consumption, I also made it worse. I now had just token consuming skill that is deterministic.</p><h4>Don’t get carried away by optimizing for AI</h4><p>This was case where randomness and even hallucinations was actually wanted to trigger creative thinking. It was reduction of hallucination risks at expense of variety and potential risks uncovering.</p><p><em>How long this took? I had already introduced Stryker to the team. And prompt to do the review without Stryker. This was work to combine them into skill. This took in total approx 3.5h including pairing with devs and 5 USD worth of tokens with Haiku 4.5 model with some Sonnet 5 in the mix.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5731b6dd0a0e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Friday night scares with LLMs — the statues, they come alive! Barely.]]></title>
            <link>https://medium.com/@misma/friday-night-scares-with-llms-the-statues-they-come-alive-barely-ec802783d37c?source=rss-0104740595ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/ec802783d37c</guid>
            <category><![CDATA[local-ai-processing]]></category>
            <category><![CDATA[ai-video-generator]]></category>
            <category><![CDATA[local-llm]]></category>
            <dc:creator><![CDATA[Misma Silfver]]></dc:creator>
            <pubDate>Mon, 31 Aug 2026 15:12:10 GMT</pubDate>
            <atom:updated>2026-08-31T15:31:35.771Z</atom:updated>
            <content:encoded><![CDATA[<p><em>What you get out of this article: starter settings for h3.c with Wan2.2 to try out image-to-video generation and tips on what to avoid.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0jgZP3so91cuT-AtCnYQWQ.png" /></figure><p>I had heard about <a href="https://comfy.org/">ComfyUI</a> before on the net and watched a tutorial or two about how to use it. Little did I know how complicated and complex it was. All I wanted to do was to animate my cats using my Macbook. As you do. And then try out creating new images using a reference images. Well, dozens of gigabytes of models later, and struggling to understand the UI all I had was an image of “orange cat in a barn playing with a yarn” that lasts 1 second. (Threw that kitty vid already out)</p><p>So on to looking for something else. I launched my ChatGPT and gave the problem description. I had already dappled with experimenting with local image-to-video generation so I had starting point preferences in my search for alternative approaches.</p><p>Come Friday evening, idea was simple enough: take a photograph of a statue and make the statue subtly come alive. Maybe turn its head, move a hand, blink. You know, all the good creepy stuff. I even had the perfect image from my trip to Poland lined up. Keep everything else in the photograph still.</p><p>What followed was a useful exercise in model selection, hardware constraints, large downloads, prompt interpretation and, finding out that statues apparently quite like being statues. More on that later.</p><h3>Starting with the hardware</h3><p>The machine:</p><p>MacBook Pro M3 Max with 36 GB unified memory.</p><p>That matters quite a lot when looking at local video-generation models. We’re not in the <a href="https://huggingface.co/google/gemma-4-E2B">Gemma 4 E4B</a> territory when talking about local image, let alone video generation.</p><p>As you probabbly know, Apple Silicon there isn’t separate system RAM and GPU VRAM. So when somebody says that a model needs 24 GB, 32 GB or 40 GB of GPU memory, the calculation is somewhat different from using an NVIDIA GPU.</p><p>But 36 GB is still 36 GB. A model wanting 60–100 GB is not magically going to fit because it is a magical Macbox.</p><p>This immediately became relevant in my hunt for Comfy alternatives, pun intented.</p><h3>First idea: MiniMax H3 and h3.c</h3><p>I found h3.c, a native inference engine for Apple Silicon. And that matters because it means it is optimized for Apple’s hardware that includes things such as Metal and MLX and the unified memory architecture.</p><p>I did not want to spend my evening building ComfyUI graphs, chasing custom nodes for templates and wondering which part of a workflow was incompatible with which other part. I had already done it and oh boy I honestly had no idea at times what was going wrong.</p><p>If you take a look at the readme in the <a href="https://github.com/antirez/h3.c">h3.c repo</a>, it’s complexity is a lot to take in. But LLMs to help with this, “just give me what I want, don’t make mistakes” and all that.</p><p>h3.c is in very simple terms closer to:</p><pre>image + prompt<br>      ↓<br>terminal command<br>      ↓<br>Metal<br>      ↓<br>video</pre><p>It even has SSD streaming support. Which sounded good: model layers can be streamed from disk rather than all sitting in memory at once. In plain terms: saves memory!</p><p>This looked promising for a 36 GB Mac.</p><p>Then came the tiny weeny problem.</p><p>The MiniMax H3 FL2VA checkpoint I needed was approximately:</p><p><strong>144 GB.</strong></p><p>Yea. No. I mean I had the disk space, I have blazing fast cable at home. But nah. Technically possible is not the same thing as sensible.</p><p>I didn’t want to dedicate that much SSD space to an experiment just to discover whether I could make a statue blink.</p><p>So the hardware constraint wasn’t actually what killed H3 for me.</p><p>The download size did. For now.</p><p>And that caused the first useful lesson of the exercise:</p><blockquote>Local AI model selection isn’t only about whether the model fits in RAM. Disk size, download size and iteration cost matter too if you’re just trying to iterate something for fun.</blockquote><p>There is more things that matter such as how costly the model is in terms of how much it thinks that can affect a lot to the tokens per second. Locally it doesn’t “cost” money (it would if you were running it in cloud though) but the slow feedback is what kills it for me with some models if output fits my need or not.</p><p>So on to next option.</p><h3>Wan 2.2 + MLX</h3><p>The alternative was Wan2.2 TI2V 5B, using an 8-bit quantized MLX version.</p><p>That has a bit different pipeline, notice it is MLX instead of Metal:</p><pre>Wan2.2 TI2V 5B<br>+<br>8-bit quantization<br>+<br>MLX<br>+<br>Apple Silicon</pre><p>The model I eventually used was:</p><pre>Anes1032/Wan2.2-TI2V-5B-mlx-q8</pre><p><a href="https://huggingface.co/Anes1032/Wan2.2-TI2V-5B-mlx-q8">Hugging Face link</a></p><p>The download is roughly 20 GB.</p><p>Twenty GB isn’t exactly tiny either, but compared with 144 GB it suddenly starts looking positively lightweight. Will it punch above it’s weightclass? Well, if I ever try the 150GB route, let’s see then.</p><p>5B parameters quantized to 8-bit turned out to be very comfortable on my M3 Max.</p><h3>Setting it up</h3><p>Create a Python virtual environment. I ran into some Python version issues. Notice that mlx-video supports Python 3.10–3.13.</p><p>Once inside the project directory, activate it:</p><pre>source .venv/bin/activate</pre><p>Install mlx-video:</p><pre>pip install -U pip<br>pip install git+https://github.com/Blaizzy/mlx-video.git</pre><p>I also needed FFmpeg. It’s used for processing the content.</p><pre>brew install ffmpeg</pre><p>And Hugging Face CLI for downloading the model:</p><pre>brew install huggingface-cli</pre><p>Then download the model when you’re in the project directory:</p><pre>hf download Anes1032/Wan2.2-TI2V-5B-mlx-q8 \<br>  --local-dir Wan2.2-TI2V-5B-MLX-Q8</pre><p>No ComfyUI. No workflow JSON. No collection of mystery nodes downloaded from GitHub that you touch and they break.</p><p>Just a model and a command line.</p><h3>First generation</h3><p>My initial test was deliberately fairly small.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*8DnAqbjjY7iaj1_e1FOHvg.jpeg" /><figcaption>Saints Peter and Paul Church, Krakow, Poland. Images in this article taken by me on location.</figcaption></figure><p>Something along these lines:</p><pre>python -m mlx_video.models.wan_2.generate \<br>  --model-dir ./Wan2.2-TI2V-5B-MLX-Q8 \<br>  --image ./statue.jpg \<br>  --prompt &quot;A weathered stone statue very subtly comes alive...&quot; \<br>  --width 480 \<br>  --height 704 \<br>  --num-frames 41 \<br>  --steps 12 \<br>  --guide-scale 5.0 \<br>  --seed 42 \<br>  --output-path statue-test.mp4</pre><p>And it worked. Read further to get breakdown of couple of those values. I have not looked into all of the options yet myself.</p><p>Not “this is going straight into a Hollywood movie” worked.</p><p>But it generated an actual video locally, from my photograph, on my MacBook. I think I saw tiny little movement lol.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fzr_LYwr2Kek%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fshorts%2Fzr_LYwr2Kek&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Fzr_LYwr2Kek%2Fhq2.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/08d3bea31371544b5a6e55a2270e17db/href">https://medium.com/media/08d3bea31371544b5a6e55a2270e17db/href</a></iframe><p>The entire thing took:</p><blockquote><strong>198 seconds.</strong></blockquote><p>That surprised me positively. All things considered.</p><p>During the denoising stage I was seeing roughly 10–11 seconds per step. VAE decoding took another 40 seconds or so.</p><p>Even more surprising was the resource usage.</p><p>Memory pressure remained largely green. CPU usage was very low because MLX was doing the interesting work through Metal on the GPU.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2TwXhCtUHIgBhLVcHDYhug.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PgE9uqaeIout__GOFN9Djw.png" /></figure><p>My 36 GB machine wasn’t remotely looking like it was about to fall over.</p><p>So Wan2.2 5B Q8 isn’t something I’m merely squeezing onto this machine. It actually seems to be a pretty reasonable model for it!</p><h3>Frames are duration</h3><p>One slightly confusing parameter initially is:</p><pre>--num-frames</pre><p>My first video used:</p><pre>41 frames</pre><p>As I didn’t see much movement and the lenght of video was shorter than I expected. Well VLC couldn’t really display properly 2 second video, it showed me 1 second. FFprobe command to the rescue:</p><pre>duration=1.708333<br>nb_frames=41</pre><p>Wan was producing 24 fps video.</p><p>So:</p><pre>41 / 24 = 1.708 seconds</pre><p>For approximately 3.4 seconds:</p><pre>81 / 24 = 3.375 seconds</pre><p>Wan expects frame counts following which can be confusing as you’d expect 24fps * number of seconds of video you want to get number of frames:</p><pre>4n + 1</pre><p>So common values are:</p><pre>41<br>81<br>121<br>...</pre><p>This becomes important with movement.</p><p>One second is actually not very much time if I’m asking a statue to:</p><ul><li>blink</li><li>turn its head</li><li>move its fingers</li><li>and somehow make that movement look gradual.</li></ul><p>The model needs time to do those things.</p><iframe src="https://cdn.embedly.com/widgets/media.html?url=https%3A%2F%2Fwww.youtube.com%2Fshorts%2FYdHQSAdVO0I&amp;type=text%2Fhtml&amp;schema=youtube&amp;display_name=YouTube&amp;src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FYdHQSAdVO0I%3Ffeature%3Doembed" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/c5d657b19564177902bf3d35d0291df1/href">https://medium.com/media/c5d657b19564177902bf3d35d0291df1/href</a></iframe><h3>Resolution is another useful calculation</h3><p>One of my other photographs was:</p><pre>1000 × 750</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*Ac_DfYwYC_kC2y7XrRwPNg.jpeg" /><figcaption>Rong Suea Ten temple, Chiang Rai, Thailand</figcaption></figure><p>That’s exactly a 4:3 aspect ratio.</p><p>Instead of feeding that resolution directly into the model, I had to whip out ChatGPT to tell what to do here. Dimensions need to be divisible by 32.</p><p>For 4:3 there are some convenient choices:</p><pre>512 × 384<br>640 × 480<br>768 × 576<br>896 × 672<br>1024 × 768</pre><p>I started with:</p><pre>640 × 480</pre><p>There is a useful lesson here too about compute power.</p><p>My earlier portrait test was:</p><pre>480 × 704 = 337,920 pixels</pre><p>while:</p><pre>640 × 480 = 307,200 pixels</pre><p>So even though 640 sounds “bigger” than 480, the 640×480 generation was actually slightly less work overall.</p><p>When experimenting with video generation, total pixel count matters more than looking at one dimension in isolation! And those numbers of pixels go up fast. And the more there is pixels, the compute power goes up.</p><h3>What do steps do?</h3><p>Steps are essentially the number of <a href="https://www.8frame.co/blog/what-is-denoising]">denoising iterations the diffusion model performs</a>.</p><pre>--steps 12</pre><p>I started with 12 and then moved to:</p><pre>--steps 20</pre><p>Very simplified:</p><pre>noise<br> ↓<br>rough structure<br> ↓<br>better structure<br> ↓<br>details<br> ↓<br>final result</pre><p>More steps generally allow the generation to converge more cleanly.</p><p>But this was one of my misconceptions during the experiment:</p><blockquote>More steps do not necessarily mean more movement.</blockquote><p>If the model has decided that the statue should mostly stay still, 20 steps may simply produce a better-looking stationary statue than 12 steps. And I thought picking up statue pics was easy starting point…</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FVDf-cySOS7I%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fshorts%2FVDf-cySOS7I&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FVDf-cySOS7I%2Fhq2.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/fdab7dade9ef2ca4222afe8a32d35f85/href">https://medium.com/media/fdab7dade9ef2ca4222afe8a32d35f85/href</a></iframe><p>Steps help quality and convergence.</p><p>They aren’t a “make the statue move more” knob.</p><h3>Guide scale turned out to be more interesting</h3><p>I initially used:</p><pre>--guide-scale 5.0</pre><p>Later I changed it to:</p><pre>--guide-scale 6.0</pre><p>Guide scale controls how strongly the model should follow the text conditioning instead of following its own learned interpretation of the image.</p><p>Low guidance:</p><blockquote>Here is an image and some suggestions. Do what seems plausible.</blockquote><p>Higher guidance:</p><blockquote>No, seriously. I told you that statue is moving. Don’t do mistakes!</blockquote><p>But this isn’t a simple “higher is better” setting either.</p><p>Push guidance too far and the model can start forcing the prompt in ways that damage visual quality or produce artifacts. So this is not exactly the LLM temperature setting either. But bit similar except when temperature goes down, model follows more strictly with less variance in possible next word. This was goes up to do the same but worse.</p><p>And I actually saw that.</p><p>One attempt gave me green artifacting and essentially no useful movement.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Ft94Q6gVMzn4%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dt94Q6gVMzn4&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Ft94Q6gVMzn4%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/c1c1dd0a746dc54d3301f9d2ff22a6e3/href">https://medium.com/media/c1c1dd0a746dc54d3301f9d2ff22a6e3/href</a></iframe><p>Generative AI experimentation in one convenient result.</p><h3>Statues like being statues</h3><p>This became the most interesting and frustrating part of the experiment.</p><p>My first statue moved slightly. Second image of Buddha is not pudging.</p><p>I tried prompts like (with the guide-scale still at 5.0):</p><blockquote>The Buddha stone statue slowly winks its eyes. The head clearly turns several degrees toward the camera. The raised hand makes a small deliberate movement and the fingers slowly shift position.</blockquote><p>Nothing.</p><p>The Buddha continued doing what it had presumably been doing quite successfully for years.</p><p>Being a statue.</p><p>I tried being more explicit:</p><blockquote>The movement develops gradually over the entire shot. The camera is absolutely locked. The background and all other elements remain completely stationary.</blockquote><p>Still almost nothing.</p><p>This is where thinking about what the model actually sees becomes useful.</p><p>The image strongly communicates:</p><p>STATUE.</p><p>The pose is rigid.</p><p>The material is rigid.</p><p>The surrounding architecture is rigid.</p><p>Thousands or millions of images in the model’s training data have presumably reinforced the same relationship:</p><pre>statue → does not move</pre><p>And then my prompt comes along asking:</p><pre>statue → move one finger slightly</pre><p>The image conditioning was apparently winning. Also, not very imaginative are we? I have seen plenty of Hollywood movies with moving statues!</p><h3>Stop asking nicely</h3><p>Eventually I decided subtlety wasn’t helping.</p><p>Instead of asking for tasteful movement, I asked for something unmistakable:</p><blockquote>The giant Buddha statue comes fully alive.</blockquote><blockquote>It rapidly turns its head to face the camera. Its eyes open wide and blink twice. The statue raises its hand high into the air and waves clearly at the camera. Its upper body leans forward as it moves. The fingers visibly open and close.</blockquote><blockquote>Large obvious animated movement. Continuous natural motion from beginning to end. The white statue remains made of solid carved material.</blockquote><blockquote>Static camera.</blockquote><p>And I combined this very strong prompt with</p><pre>guide-scale 6</pre><p>Finally:</p><p>the statue moved.</p><p>I didn’t get scary Thai ghost story but it moved. With silly looking hand movement. But now you can’t miss it anymore!</p><iframe src="https://cdn.embedly.com/widgets/media.html?url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DYWl-8mC4jaM&amp;type=text%2Fhtml&amp;schema=youtube&amp;display_name=YouTube&amp;src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FYWl-8mC4jaM%3Ffeature%3Doembed" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/d27f15444137584c0fb20f9203656642/href">https://medium.com/media/d27f15444137584c0fb20f9203656642/href</a></iframe><p>The result isn’t particularly good.</p><p>But that wasn’t the point anymore.</p><p>The experiment had changed from:</p><blockquote>Can I make a beautiful animation?</blockquote><p>to:</p><blockquote>Can I force this model to animate this particular subject at all?</blockquote><p>And now I had the answer. No AI animation award for me and my Macbook though.</p><h3>This is a useful way to debug generative AI</h3><p>I think this was probably the most useful lesson from the whole exercise. Something I had not ran into when using LLMs for work and off-work creation that is all about text input-output. With the occasional flowcharts and illustrations.</p><p>When the subtle prompt isn’t working, don’t keep making tiny changes to words like:</p><pre>slowly<br>slightly<br>gently<br>clearly</pre><p>Increase the signal until the behavior becomes unmistakable. Especially when dealing with these super short video lengths due to hardware constraints.</p><p>Instead of:</p><blockquote>Move the hand slightly.</blockquote><p>Try:</p><blockquote>Raise the arm and wave at the camera.</blockquote><p>Instead of:</p><blockquote>Turn the head a little.</blockquote><p>Try:</p><blockquote>Turn the head thirty degrees directly toward the viewer.</blockquote><p>Once that works, reduce the effect.</p><p>That gives me something resembling a boundary test. My little QA brain celebrates:</p><pre>no movement<br>     ↓<br>small movement<br>     ↓<br>obvious movement  ← model finally responds<br>     ↓<br>reduce movement again<br>     ↓<br>desired result</pre><p>This isn’t very different from how I would approach plenty of other technical and testing problems weekly.</p><p>First establish that the mechanism works.</p><p>Then optimize it.</p><h3>Prompt constraints can also work against you</h3><p>There was another mistake in my early prompts.</p><p>I was saying:</p><pre>move</pre><p>while simultaneously filling the rest of the prompt with:</p><pre>subtle<br>small<br>stationary<br>locked<br>no morphing<br>no dramatic movement<br>no changing background</pre><p>I was trying to protect the photograph. But I was also giving the model a lot of reasons not to change anything.</p><p>My negative prompt included something like this (I didn’t add that to the command example earlier for clarity’s sake):</p><pre>--negative-prompt &quot;camera movement, zoom, pan, morphing, melting, distorted architecture, <br>changing background, human skin, color, dramatic movement</pre><p>while I was complaining how stupid this model is that nothing dramatic enough was happening.</p><p>Once I wanted to diagnose movement, I simplified the negative prompt substantially:</p><pre>camera shake, camera pan, camera zoom,<br>distorted face, melting, deformed hands</pre><p>First get motion. Then tighten the constraints.</p><h3>Where I ended up</h3><p>At the end of the evening I had:</p><ul><li>local image-to-video generation running on an M3 Max;</li><li>a roughly 20 GB quantized Wan model;</li><li>generation times measured in minutes, not hours;</li><li>plenty of usable memory headroom;</li><li>41- and 81-frame experiments;</li><li>an understanding of how steps and guidance affect very different parts of the problem;</li><li>one statue that moved fairly easily;</li><li>and one Buddha statue that required considerably more persuasion.</li></ul><p>There is still a lot to improve. And the big problem is the slow feedback time. You can imagine leaving your machine to run for an hour or two to come back to a 20 seconds of video that is totally unusable.</p><p>The current successful “Buddha comes alive” result looks worse than the original photograph. That’s expected because deliberately pushed the model toward movement rather than movie quality.</p><p>The next problem is:</p><blockquote>Now that I know the statue can move and that my setup is working. How far can I reduce the movement and guidance while keeping it alive? How many second video I need to generate for this to work?</blockquote><p>That’s a much better problem to have than a perfectly preserved photograph of a statue stubbornly refusing to do anything. Here’s to statues for being statues. Thank Buddha. It would be scary otherwise.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ec802783d37c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Notes from the QA desk: AI is not deterministic — use Google to find a better tool for the job]]></title>
            <link>https://medium.com/@misma/notes-from-the-qa-desk-ai-is-not-deterministic-use-google-to-find-a-better-tool-for-the-job-0dbcf0185e9f?source=rss-0104740595ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/0dbcf0185e9f</guid>
            <category><![CDATA[critical-thinking]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Misma Silfver]]></dc:creator>
            <pubDate>Fri, 28 Aug 2026 05:48:56 GMT</pubDate>
            <atom:updated>2026-08-28T10:20:16.029Z</atom:updated>
            <content:encoded><![CDATA[<p><em>As agentic usage has taken off, I nudge teams almost daily about the nature of LLMs as gentle reminder on not forgetting scripts and other non AI tools. Trigger for writing this was not that but when a team noted in AI in software development catch up that their skill didn’t trigger another skill even though all the “keywords” were in place.</em></p><p>AI literally guesses (more precisely predicts what should come next based on statistical patterns) what text could “mean”, it doesn’t understand any language like humans. It does this to very good level by having processed staggering amount of books, webpages, code in world in every language.</p><p>And as humans we already understand same words in same language differently depending on words used. We see this on every project and initiative we do. We define terms what we use as a team. And those same words often mean different things to different team.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2P9LwZpl-vZ1QA7IOq7Dxw.jpeg" /><figcaption><em>Photo by </em><a href="https://unsplash.com/@davidmatos?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText"><em>David Matos</em></a><em> on </em><a href="https://unsplash.com/photos/human-anatomy-model-xtLIgpytpck?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText"><em>Unsplash</em></a></figcaption></figure><p>But now drop from metaphor any human-like brain function and replace it with statistical variation that creates illusion of “creativity” and “understanding”. LLMs do not process it through lived experience, human understanding or intent.</p><p>Large language models try to transfer things to what is statistically best guess for next step, next “word”, using large multidimensional probability maps. This is also what creates the illusion of creativity and understanding: variation. And that variation is what can cause LLM to not read instructions as it predicts what it is expected to do next.</p><p>One method to reduce this statistical variance built into language model is to use deterministic tools, ie tools that follow strict algorthim and not statistical “next best word guess”. You give it same input, it produces same output 100 times out of 100.</p><p>In short, use LLM when interpretation and flexibility are valuable. Use deterministic mechanisms where correctness and repeatability are required. Examples of this in programming are tools like linters and static accessibility analysis tools that look for accessibility issues in code. Try this with skill files, give them instructions to trigger these tools. But remember, to get to that tool calling step in your skill file, well, that is a the variation chance you take.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0dbcf0185e9f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Evaluating architecture “ilities” before implementation for quality]]></title>
            <link>https://medium.com/@misma/evaluating-architecture-bilities-before-implementation-for-quality-9c37aaa8476d?source=rss-0104740595ae------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c37aaa8476d</guid>
            <dc:creator><![CDATA[Misma Silfver]]></dc:creator>
            <pubDate>Tue, 10 Feb 2026 06:56:51 GMT</pubDate>
            <atom:updated>2026-02-11T00:19:47.883Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5QLOv4FeoaJK12yNcACZgw.jpeg" /><figcaption>Cropped from photo by <a href="https://unsplash.com/@sylwiabartyzel?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Sylwia Bartyzel</a> on <a href="https://unsplash.com/photos/a-large-wooden-structure-with-a-clock-on-its-side-2fYXPV-kGTs?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>When thinking all the aspects that might define “what quality means”, there is several so called “ilities”. If quality is something that matters to someone who matters then it is more than likely your project has several “bilities” even if you are not yet aware of them. Maybe your delivery team has goals to improve many aspects of a new product you’re developing. Some of these might be maintainability, observability, testability and deployability. These are all so called -bilities. It includes also other things such as security and accessibility. But we’re not looking into those here.</p><p>Instead, let’s see what we could do before single line has been written yet and you’re looking at your new architecture plans!</p><p><em>Generative AI tools were used to extract bullet points for the different abilities. Content has been “spiced” up by me using my experience across various software projects</em></p><h3>Maintainability: The Future-Proof Lens</h3><p>How easily the system we’re desiginging can evolve, repair, or improve without breaking existing functionality?</p><p>Following might apply to your design, maybe not.</p><p><strong>Key Principles:</strong></p><ul><li><strong>Coupling &amp; Cohesion</strong>: Identify God Components (components with too many responsibilities) or tangled dependencies. This is bit like the infamous God Class.</li><li><strong>Abstraction Layers</strong>: Verify implementation details are hidden (can you swap databases without rewriting business logic?). This might be familiar to you from “good tests”, be they unit, integration or end to end tests. Can you switch frameworks, tools “easily”.</li><li><strong>Standardization</strong>: Consistent patterns for error handling, logging, data access, and configuration</li><li><strong>Configuration Management</strong>: How settings and secrets flow across environments.</li><li><strong>Backward Compatibility</strong>: Check mechanisms to prevent breaking changes, not just handle them</li><li><strong>Technical Debt Visibility</strong>: Confirm architecture exposes complexity metrics</li></ul><p>Remember, there is such thing as “too much of a good thing”. Sometimes for example abstractions can become too abstract. One aspect of maintainability is “how easy it is for a new person to jump in”.</p><h3>Observability: The Internal Health Lens</h3><p>Can we quickly observe and track things as they move across the architecture. And especially if something goes wrong.</p><p><strong>Key Principles:</strong></p><ul><li><strong>Traceability</strong>: In distributed systems, can you track single requests across all services?</li><li><strong>Measurement Consistency</strong>: Specify what’s measured (business metrics vs. infrastructure) and ensure uniform collection methods. This can be tricky in large organisations and multiple teams.</li><li><strong>Context Enrichment</strong>: Include Correlation IDs and metadata for meaningful logs and metrics</li><li><strong>Alerting Strategy</strong>: Define when and how teams receive notifications</li><li><strong>Debugging Workflows</strong>: Map the path from alert to resolution</li><li><strong>Security &amp; Audit</strong>: Track security events and compliance trails</li><li><strong>Cost Visibility</strong>: Monitor observability infrastructure overhead</li></ul><p>If you’re only one team dealing with the architecture under design, things can be much easier than in large organisation. As sometimes you need to do with what tooling is available for you. Just because you want to track something across distributed systems, is it even feasable? Do you get enough “bang for buck” if you implement partial traceability?</p><h3>Testability: The Verification Lens</h3><p>Testability measures how easily you can verify system and test the system. I am using here both words verify, associated with automated testing, and test system for what could be described as exploratory testing.</p><p><strong>Key Principles:</strong></p><ul><li><strong>Isolation</strong>: Test components independently without full infrastructure</li><li><strong>Determinism</strong>: Minimize side effects causing flaky tests (hidden global states)</li><li><strong>Controllability</strong>: Inject failures and bad data to validate resilience</li><li><strong>Contract Validation</strong>: Verify service agreements in distributed systems</li><li><strong>Performance Testing</strong>: Support load and stress testing scenarios</li><li><strong>Privacy-Safe Data</strong>: Generate test data respecting compliance requirements</li><li><strong>Deployment Testing</strong>: Validate the deployment process itself</li></ul><p>Once again, your situation is different. What if you cannot control test data? Is there any ways you can create mocks, containers or similar to control things that are outside your control? This can be affect greatly the speed at which your team moves if you’re waiting days for test data availability for single round of automated or especially exploratory testing. Isolation becomes very important factor. But then you really need to understand also how the systems you’re interfacing with can fail, behave. So you need to take this into account when your team is defining your test strategy.</p><h3>Deployability: The Production Release Lens</h3><p>Deployability measures how safely and efficiently code reaches production.</p><p><strong>Key Principles:</strong></p><ul><li><strong>Deployment Independence</strong>: Deploy components without coordinated releases</li><li><strong>Rollback Mechanisms</strong>: Quick reversion when issues arise</li><li><strong>Progressive Delivery</strong>: Support blue/green, canary, and feature flag patterns</li><li><strong>Environment Parity</strong>: Minimize differences between dev, staging, and production</li><li><strong>Automation</strong>: Reduce manual steps and human error</li></ul><p>This can be important goal for your team especially in monolith to microservice migration projects. What guidelines your team needs to follow from the organisation? How much you can decouple and when you can start moving faster? Is the architecture plan mix and match of monolith and microservice architecture? What service and server architecture you have available for example to reach environment parity?</p><h3>The Checklist Questions for Each bility</h3><p>When your team is working on the plans, here is some questions that can be relevant. Remember, we’re dealing here with the architecture planning phase. And no, doesn’t mean we are dealing with waterfall SDLC.</p><p>I recognize that architecture also emerges as you go. And some of these questions are not relevant for you in early architecture planning. But they will become important as your solution starts maturing. So it is good thing to be aware of them now and get back to them when time is more mature.</p><h3>Maintainability Questions</h3><p><strong>The Replaceability Test</strong>: If replacing the primary database or third-party API, how many components require modification? This is sort of thing to consider, if we’re already replacing some APIs, what happens if say the payment gateway API changes again as they often can.</p><p><strong>The New Hire Test</strong>: Can new developers understand a module’s purpose without reading system-wide documentation? This is one of my favorite “flags” for maintainability. If we assume you’re say starting from the infamous “big ball of mud”, you want the end up with much streamlined, easier to understand landscape.</p><p><strong>Dependency Mapping</strong>: Are there circular dependencies between services that we’re drafting?</p><p><strong>Version Strategy</strong>: How does the architecture handle API breaking changes? Is versioning built-in? When you’re moving into microservices out from monoliths, expect APIs to start changing more often too as the organisation gaines more momentum for changes thanks to the microservices.</p><p><strong>The Configuration Chaos Test</strong>: Can you trace how a single setting propagates from source to runtime? Are secrets managed securely? This could go as well in observability section.</p><p><strong>The Abandoned Code Test</strong>: How are we identifying unused services or features for removal? How we find out if someone else is still using it?</p><p><strong>Documentation Auto-Generation</strong>: Does the architecture support generating docs from code (OpenAPI specs, dependency graphs)?</p><h3>Observability Questions</h3><p><strong>The Needle in a Haystack Test</strong>: When users report errors, what unique ID finds the exact log entry across all services? What hidden assumptions we might have of the observability tools we have?</p><p><strong>The New Hire Test (Observability)</strong>: Can someone new understand telemetry without tribal knowledge?</p><p><strong>Health Definitions</strong>: Does the architecture define Healthy vs. Degraded vs. Down states for each component? Can it? Which parts of the architecture can report different states, and what does it mean from the point of view of cascading problems?</p><p><strong>Measurement Standards</strong>: Is there consistent format for logs (JSON with standard fields) and metrics (naming conventions, labels) across the entire system? What can we do in our team to start implementing these good practises?</p><p><strong>The 2 AM Test</strong>: If this breaks at 2 AM, what does the on-call engineer see first? Is it actionable?</p><p><strong>The Regulatory Audit Test</strong>: Can you prove what happened six months ago? Are audit logs tamper-proof?</p><p><strong>Cost Attribution</strong>: Can you track observability costs per service or team? What are the cost implications of our teams observability riggings?</p><h3>Testability Questions</h3><p><strong>Mock-ability</strong>: Are external dependencies (APIs, databases, file systems) hidden behind interfaces for easy mocking?</p><p><strong>State Management</strong>: How do you reset the system to a clean state for automated checks and verifications?</p><p><strong>Failure Injection</strong>: What do we need to do with our plans to allow us to create intentional failures? Time outs, cut connections. Wrong API versions.</p><p><strong>Data Seeding</strong>: Is there a clear path for generating and injecting test data?</p><p><strong>Contract Testing</strong>: How do you verify service contracts (API schemas, message formats) between teams?</p><p><strong>Performance Baselines</strong>: Can you run load tests that mirror production traffic patterns? Which parts of your architecture you can exercise that are under your control? How you isolate 3rd parties or agree on test windows?</p><p><strong>Privacy Compliance</strong>: Does test data generation anonymize or synthesize sensitive information?</p><p><strong>Environment Cloning</strong>: Can you replicate production-like conditions in test environments?</p><h3>Deployability Questions</h3><p><strong>The Solo Deploy Test</strong>: Can you deploy one service without coordinating with other teams?</p><p><strong>Rollback Speed</strong>: How quickly can you revert to the previous version? Is it automated?</p><p><strong>Progressive Delivery</strong>: Does the architecture support canary releases (deploying to 5% of users first)?</p><p><strong>Feature Flags</strong>: Can you toggle functionality without deploying code?</p><p><strong>Environment Promotion</strong>: How do artifacts move from dev to staging to production? Are they identical?</p><p><strong>The Zero-Downtime Test</strong>: Can you deploy during business hours without user impact?</p><p><strong>Deployment Observability</strong>: Do deployments generate telemetry showing their progress and impact?</p><p><strong>Disaster Recovery</strong>: Can you test failover procedures without causing downtime?</p><h3>In Conclusion</h3><p>You notice how much these related to testing. Testing failovers, testing in production with progressive delivery and flags for example. No wonder maintainability, observability, deployability are classified as software quality attributes. Or maybe that is because of my own bias as a quality advocate, tester and QA.</p><p>So there you have it, a lot could be also written say on asking as a team cross cutting questions on these bilities that highlight where they intersect. Such as intersection of maintainability and observability. Or maybe “red flags” for your architecture design phases. And this doesn’t cover other bilities such as resilience.</p><p>Talking explicitly about these kind of abilities in architecture drafting phase is one of those things that can shift quality left. And if you’re a QA, bring these up with your product owner, product manger, project manager. Work with them on the business goals of your project, and find out what goals might be hidden in the technical side and expectations that do not reflect directly to end user say in form of a product feature (“add product to cart”, “publish a blog post”.).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c37aaa8476d" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>