<?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: Built By AI Lab</title>
    <description>The latest articles on DEV Community by Built By AI Lab (@builtbyailab).</description>
    <link>https://dev.to/builtbyailab</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%2F4155432%2F4186b60a-1532-4edf-b6db-e63440fc4574.jpg</url>
      <title>DEV Community: Built By AI Lab</title>
      <link>https://dev.to/builtbyailab</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/builtbyailab"/>
    <language>en</language>
    <item>
      <title>A phone number that would have gone to France</title>
      <dc:creator>Built By AI Lab</dc:creator>
      <pubDate>Wed, 18 Nov 2026 14:11:52 +0000</pubDate>
      <link>https://dev.to/builtbyailab/a-phone-number-that-would-have-gone-to-france-1hg</link>
      <guid>https://dev.to/builtbyailab/a-phone-number-that-would-have-gone-to-france-1hg</guid>
      <description>&lt;p&gt;My app opens WhatsApp with a wa.me link, and the link needs the phone number in international format: digits only, with the country code at the front. The first version of my function removed spaces and symbols and did nothing else.&lt;/p&gt;

&lt;p&gt;Italian mobile numbers start with 3, so a customer saved as "333 1234567" turned into wa.me/3331234567, and WhatsApp reads the first digits as a country code. 33 is France. A number starting with 340 reads as 34, which is Spain, and one starting with 320 reads as 32, which is Belgium. The message that goes out carries the customer's name, her dog's name and the salon's name, and it would have landed with a stranger.&lt;/p&gt;

&lt;p&gt;I never noticed, because every number I had typed during development started with +39. The reviewer fed the function twenty different inputs. The ones written with +39, 0039 or 39 in front worked. A landline like "091 6111222" came out as a link that was not valid, and "12345" came out as a link too. Even "abc" produced one, an empty link. Nothing in the old function could say no.&lt;/p&gt;

&lt;p&gt;The new function brings every number to international format. A mobile number that starts with 3 gets the prefix 39, and so does a landline that starts with 0. Anything it cannot recognize is refused, and the send button checks that before the state of the offer changes. The same normalized number feeds the exclusion list, which means a customer who asks to be removed stays removed even if a later file writes her number with a space, a dash or a +39.&lt;/p&gt;

&lt;p&gt;The twenty inputs are now a test, and I added a few numbers from my own contact list that I had never thought to try.&lt;/p&gt;

&lt;p&gt;What I keep from this is a habit: data from a file or a form gets normalized once, at the door, and the app uses that single form everywhere afterwards.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Disclosure: drafted with a local AI model, then reviewed and approved by me. Originally published at &lt;a href="https://bbal-blog.kairo-app.workers.dev/a-phone-number-that-would-have-gone-to-france/" rel="noopener noreferrer"&gt;https://bbal-blog.kairo-app.workers.dev/a-phone-number-that-would-have-gone-to-france/&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>abotwrotethis</category>
      <category>ai</category>
      <category>devjournal</category>
    </item>
    <item>
      <title>Designing around a free tier: 50 database operations per request</title>
      <dc:creator>Built By AI Lab</dc:creator>
      <pubDate>Tue, 17 Nov 2026 14:12:13 +0000</pubDate>
      <link>https://dev.to/builtbyailab/designing-around-a-free-tier-50-database-operations-per-request-2amf</link>
      <guid>https://dev.to/builtbyailab/designing-around-a-free-tier-50-database-operations-per-request-2amf</guid>
      <description>&lt;p&gt;The database behind the app is Cloudflare D1 on the free plan, so the monthly bill for hosting is zero. The plan comes with a limit: one request may run at most 50 operations against the database.&lt;/p&gt;

&lt;p&gt;For a long time I did not know the limit mattered. The app was small, my test data was small, and each page asked the database a handful of questions. Then the acceptance round arrived with 500 customers and 2000 appointments, and the test showed two features that would have stopped halfway on a real file.&lt;/p&gt;

&lt;p&gt;The Excel import was the first. It walked through the file one row at a time, and each row cost several operations: look up the customer, create or update it, look up the service, look up the appointment, write it. A file with a few dozen rows would use up the allowance, and the request would end with half the rows saved and half not. The second was the agenda reader, which sends the day's appointments in one request and did the same thing row by row.&lt;/p&gt;

&lt;p&gt;The fix is to work in batches. The import now takes the rows in groups, with a handful of statements bundled into one call, and it continues until the file is finished, whatever its size. The agenda reader does the same.&lt;/p&gt;

&lt;p&gt;The scoring that picks candidates for a free slot had a related problem. For every customer it asked the database six separate questions, which is fine for ten customers and not for five hundred. I rewrote it to ask a few questions that cover all the customers at once, and it computes the scores in memory.&lt;/p&gt;

&lt;p&gt;What I take from this is that a limit on the free plan is a requirement for the design, and I should write it down on the first day. It costs very little to build with the limit in mind. It costs a lot to find it out when the first real salon sends a file with 800 rows.&lt;/p&gt;

&lt;p&gt;The fake data were also the cheapest way to meet it. Five hundred invented customers took a few minutes to generate, and the first real customer never saw the failure.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Disclosure: drafted with a local AI model, then reviewed and approved by me. Originally published at &lt;a href="https://bbal-blog.kairo-app.workers.dev/designing-around-a-free-tier-50-database-operations-per/" rel="noopener noreferrer"&gt;https://bbal-blog.kairo-app.workers.dev/designing-around-a-free-tier-50-database-operations-per/&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>abotwrotethis</category>
      <category>ai</category>
      <category>devjournal</category>
    </item>
    <item>
      <title>Demo data should never be dialable</title>
      <dc:creator>Built By AI Lab</dc:creator>
      <pubDate>Mon, 16 Nov 2026 19:39:46 +0000</pubDate>
      <link>https://dev.to/builtbyailab/demo-data-should-never-be-dialable-2m4h</link>
      <guid>https://dev.to/builtbyailab/demo-data-should-never-be-dialable-2m4h</guid>
      <description>&lt;p&gt;To show the app to people, and to take screenshots of every page in two themes and two screen sizes, I created a demo salon with 40 invented customers. Each had a name, a dog and a phone number. I made the numbers look real, because an empty table or a column of zeros does not show how the screens look in use.&lt;/p&gt;

&lt;p&gt;The review pointed straight at those numbers, which were valid Italian mobile numbers written the way a real customer would write hers, and a number that looks real may belong to somebody. In simulation mode nothing gets sent. The app can also switch to a mode that builds a link to open WhatsApp, and if anyone had flipped that setting in the demo and pressed the button, a promotional message with an invented name in it would have reached a stranger.&lt;/p&gt;

&lt;p&gt;Two changes followed from that. The demo numbers now start with +39 000, a range that no operator assigns, so a link built from one of them goes nowhere. On top of that the demo organization cannot switch to the link mode at all, and the server checks it before it prepares any message, whatever the settings page says.&lt;/p&gt;

&lt;p&gt;The same thought applies to test data in general, because invented names are harmless and so are email addresses at a domain reserved for examples. Phone numbers, postal addresses and anything else that a person or a service can act on need to be built so that acting on them is impossible, and the cheapest moment to do it is the first day, when you write the generator.&lt;/p&gt;

&lt;p&gt;The rule I keep from this is that demo data should be safe to touch, and that the safety should come from how it is built and never from the hope that nobody clicks.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Disclosure: drafted with a local AI model, then reviewed and approved by me. Originally published at &lt;a href="https://bbal-blog.kairo-app.workers.dev/demo-data-should-never-be-dialable/" rel="noopener noreferrer"&gt;https://bbal-blog.kairo-app.workers.dev/demo-data-should-never-be-dialable/&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>abotwrotethis</category>
      <category>ai</category>
      <category>devjournal</category>
    </item>
    <item>
      <title>When a security header blocks your own app</title>
      <dc:creator>Built By AI Lab</dc:creator>
      <pubDate>Sat, 14 Nov 2026 15:09:52 +0000</pubDate>
      <link>https://dev.to/builtbyailab/when-a-security-header-blocks-your-own-app-4blk</link>
      <guid>https://dev.to/builtbyailab/when-a-security-header-blocks-your-own-app-4blk</guid>
      <description>&lt;p&gt;I had added a Content Security Policy to the app with script-src set to 'self'. The idea is sound: the browser runs scripts that come from my own domain and refuses everything else. I checked that the header was present on the live site, marked the item as done in my notes and moved on.&lt;/p&gt;

&lt;p&gt;SvelteKit starts each page with a short inline script. The browser read my policy literally and refused it. The page text and the forms were there, because the server had already produced them. The part of the app that runs in the browser never started. Without it, the screens that refresh themselves every 45 seconds did not refresh, the service worker was never registered, and the Excel import, which parses the file in the browser, could not run at all.&lt;/p&gt;

&lt;p&gt;I did not see it, and my earlier security report said the CSP was correct. The reviewer opened the login page in a browser and read the console. It had two errors, each one beginning with "Executing inline script violates the following Content Security Policy directive 'script-src self'", and each one went on to say that a hash or a nonce was required.&lt;/p&gt;

&lt;p&gt;The fix is the kit.csp setting in SvelteKit, which adds a nonce to the scripts it generates. Each response gets its own random value, the policy allows that value and my own domain, and the browser accepts the framework's script without allowing every inline script. The inline code that registers the service worker moved to a separate file.&lt;/p&gt;

&lt;p&gt;Then a headless Puppeteer session opened the login and privacy pages. The console was empty, the page had started and the service worker was registered. I run that check again after every change to the headers.&lt;/p&gt;

&lt;p&gt;The habit I took from it is that a security setting is tested in a real browser, with the console open. A header that exists on the wire tells me nothing about whether the app still runs.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Disclosure: drafted with a local AI model, then reviewed and approved by me. Originally published at &lt;a href="https://bbal-blog.kairo-app.workers.dev/when-a-security-header-blocks-your-own-app/" rel="noopener noreferrer"&gt;https://bbal-blog.kairo-app.workers.dev/when-a-security-header-blocks-your-own-app/&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>abotwrotethis</category>
      <category>ai</category>
      <category>devjournal</category>
    </item>
    <item>
      <title>A renamed cookie and a logout button that did nothing</title>
      <dc:creator>Built By AI Lab</dc:creator>
      <pubDate>Fri, 13 Nov 2026 14:11:22 +0000</pubDate>
      <link>https://dev.to/builtbyailab/a-renamed-cookie-and-a-logout-button-that-did-nothing-3k8g</link>
      <guid>https://dev.to/builtbyailab/a-renamed-cookie-and-a-logout-button-that-did-nothing-3k8g</guid>
      <description>&lt;p&gt;After the first review I renamed the session cookie to __Host-session. The prefix makes the browser accept the cookie only over HTTPS, with no domain attribute and with the path set to the root, which closes a few ways of planting a fake session. Login and the password change both started using the new name.&lt;/p&gt;

&lt;p&gt;The logout code kept the old one. It read a cookie called session, found nothing, deleted nothing on the server and cleared a cookie that no longer existed. The Exit button redirected to the login page and looked as if it had worked. The session row in the database stayed valid, and so did the cookie in the browser, for up to 14 days. On a salon computer that two people share, the second person would open the clients page and be logged in as the first.&lt;/p&gt;

&lt;p&gt;Every automated test passed. I had tests for the password hash, for the rate limit, for the form validation. None of them pressed Exit and then asked whether the session still worked.&lt;/p&gt;

&lt;p&gt;The reviewer found it by reading the logout file next to the login file. The two files used different names for the same thing, and that difference is easy to see when you read both in one sitting and easy to miss when you wrote them in different weeks.&lt;/p&gt;

&lt;p&gt;The fix took one line. The logout now reads __Host-session, falls back to the old name for anyone still holding one, deletes the session row and clears both cookies. A new test checks that the logout file mentions the new cookie, which is a modest test, and it exists because I have seen what happens without it.&lt;/p&gt;

&lt;p&gt;When I rename something that appears in several files, I search the whole project for the old name before I call the job finished. When a feature touches security, I also ask what a user does with it: log in, log out, log in again, and see if the old session still works.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Disclosure: drafted with a local AI model, then reviewed and approved by me. Originally published at &lt;a href="https://bbal-blog.kairo-app.workers.dev/a-renamed-cookie-and-a-logout-button-that-did-nothing/" rel="noopener noreferrer"&gt;https://bbal-blog.kairo-app.workers.dev/a-renamed-cookie-and-a-logout-button-that-did-nothing/&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>abotwrotethis</category>
      <category>ai</category>
      <category>devjournal</category>
    </item>
    <item>
      <title>How I brief an AI reviewer</title>
      <dc:creator>Built By AI Lab</dc:creator>
      <pubDate>Thu, 12 Nov 2026 14:11:59 +0000</pubDate>
      <link>https://dev.to/builtbyailab/how-i-brief-an-ai-reviewer-3ki4</link>
      <guid>https://dev.to/builtbyailab/how-i-brief-an-ai-reviewer-3ki4</guid>
      <description>&lt;p&gt;A reviewer is only as good as the brief it receives, and my first one was a friendly paragraph of five lines. The report that came back was a polite list of small things, so over six rounds the instructions changed a great deal.&lt;/p&gt;

&lt;p&gt;The reviewer is a separate AI session from the one that built the code, and it has read-only access. It can read files, run the tests and the type checker, and send harmless test requests to the live site. It cannot edit code, deploy, touch the database or contact any external service the app depends on, and I wrote those limits into the brief itself instead of trusting the reviewer's judgment to hold them.&lt;/p&gt;

&lt;p&gt;Before anything else it reads the previous reports, which tell it what has been claimed as fixed. Then it believes none of it. For each claim it opens the code, finds the line and, where possible, tries the live site. That rule has paid for itself more than once: one of my own reports said a webhook now verified signatures, and the verification function was sitting in the file with nothing calling it. The reviewer sent an unsigned request and got a success answer back.&lt;/p&gt;

&lt;p&gt;Only plain tests are allowed: a GET or a POST with made-up data, a headless browser that opens pages and reads the console, the test suite, the type check and the dependency audit. It must not try to guess passwords, and it must not use real customer data.&lt;/p&gt;

&lt;p&gt;Each report has the same shape, with the flaws in the code, the legal and privacy risks and the things done well in three separate sections. Findings are sorted by severity, and each carries the file and line, a concrete scenario for how it goes wrong, a proposed fix and a label saying whether the reviewer verified it or only suspects it. A finding with no scenario goes back to the reviewer.&lt;/p&gt;

&lt;p&gt;The report closes with a verdict in plain words: ready for fake data, ready for a small pilot with real data, or not ready, followed by the reasons. By the sixth round the verdict was a yes for a manual pilot with one condition, a signed data processing contract.&lt;/p&gt;

&lt;p&gt;I have also learned to keep the builder out of the verdict. The agent that writes a fix is the wrong one to say that it works.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Disclosure: drafted with a local AI model, then reviewed and approved by me. Originally published at &lt;a href="https://bbal-blog.kairo-app.workers.dev/how-i-brief-an-ai-reviewer/" rel="noopener noreferrer"&gt;https://bbal-blog.kairo-app.workers.dev/how-i-brief-an-ai-reviewer/&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>abotwrotethis</category>
      <category>ai</category>
      <category>devjournal</category>
    </item>
    <item>
      <title>Acceptance testing a small app with fake data: 61 scenarios</title>
      <dc:creator>Built By AI Lab</dc:creator>
      <pubDate>Wed, 11 Nov 2026 14:13:11 +0000</pubDate>
      <link>https://dev.to/builtbyailab/acceptance-testing-a-small-app-with-fake-data-61-scenarios-5e55</link>
      <guid>https://dev.to/builtbyailab/acceptance-testing-a-small-app-with-fake-data-61-scenarios-5e55</guid>
      <description>&lt;p&gt;Automated tests tell me that the code does what I wrote. An acceptance test asks a different question: can someone do their actual job with it. So before a real salon touched the app, a separate AI session played the part of the owner on a test computer with fake data. It ran 61 scenarios in four rounds.&lt;/p&gt;

&lt;p&gt;The first round found 19 defects, some of them serious. All were fixed. The later rounds came back clean.&lt;/p&gt;

&lt;p&gt;The scenarios were chosen to be annoying. First login, with the forced password change. Too many wrong passwords, and what the lock does. An Excel file with Italian column names, dates in three formats, phone numbers written with spaces, dashes and a +39 in front, accented names and a few broken rows. The same file imported twice. A cancellation that happens between two imports. A computer whose clock was set to the wrong time zone. Two salons with several users each, to see that nothing leaks across them and that a member of staff cannot reach the owner's settings. A list of 500 customers with 2000 appointments, to see how the pages behave when the table stops being small. A double click, a slow network, no network, and a session that expires while a form is open.&lt;/p&gt;

&lt;p&gt;It also checked how the app looks at 390 pixels wide, which is a phone, and on a desktop, in the light and the dark theme, and whether every form can be used from the keyboard.&lt;/p&gt;

&lt;p&gt;The report is honest about what it could not prove. The real Excel export of the salon's booking software and a real WhatsApp message are not reachable from a test computer. Those became a short list for the first session with the owner: log in, import two weeks of appointments, check three of them against the original, report a free slot by hand and open the link on the owner's own phone.&lt;/p&gt;

&lt;p&gt;I now run an acceptance round before I hand any app to someone. It finds a different kind of mistake from the one my tests find.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Disclosure: drafted with a local AI model, then reviewed and approved by me. Originally published at &lt;a href="https://bbal-blog.kairo-app.workers.dev/acceptance-testing-a-small-app-with-fake-data-61-scenarios/" rel="noopener noreferrer"&gt;https://bbal-blog.kairo-app.workers.dev/acceptance-testing-a-small-app-with-fake-data-61-scenarios/&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>abotwrotethis</category>
      <category>ai</category>
      <category>devjournal</category>
    </item>
    <item>
      <title>Failing closed: three places where my app says no when unsure</title>
      <dc:creator>Built By AI Lab</dc:creator>
      <pubDate>Thu, 05 Nov 2026 19:37:55 +0000</pubDate>
      <link>https://dev.to/builtbyailab/failing-closed-three-places-where-my-app-says-no-when-unsure-4jg4</link>
      <guid>https://dev.to/builtbyailab/failing-closed-three-places-where-my-app-says-no-when-unsure-4jg4</guid>
      <description>&lt;p&gt;A program meets situations its author did not plan for. A database connection that is missing in one environment. A request that arrives at an endpoint nobody switched on. A message with no signature. In each of those moments the code has to choose between going on and stopping, and I now write the choice down on purpose.&lt;/p&gt;

&lt;p&gt;The first place is the entry point of the whole app. If the connection to the database is missing, every page returns a 503 and a short message, with one exception: the public privacy page, which holds only text. Earlier, a missing connection skipped the login check and served the pages anyway. They showed empty lists, because there was nothing to read, but the pattern is wrong. A configuration mistake in a preview environment should produce an outage, and it should not produce an open door.&lt;/p&gt;

&lt;p&gt;The second place is the endpoint for incoming WhatsApp messages. It is switched off by default. Until an owner turns it on, the endpoint answers 404 and does nothing, which was the review's finding when it first sent an empty request and got a 200 instead. A thing that is off should look off from the outside.&lt;/p&gt;

&lt;p&gt;The third place is the signature. When the endpoint is on, each request must carry a signature made with a shared secret. If the secret is not configured, or the signature is missing or wrong, the message is dropped. In an earlier version a check existed on paper and nothing called it, so an unsigned message with the word STOP or YES would have changed a customer's status. Now there is no path from an unsigned request to a database write.&lt;/p&gt;

&lt;p&gt;Sending follows the same idea. The default mode is a simulation that records what would have been sent and sends nothing. Moving to real links is a conscious change in settings made by the owner, and the app never offers automatic sending.&lt;/p&gt;

&lt;p&gt;A rule I use when I write this kind of code: for every external input, I ask what happens if it is absent and what happens if it is wrong, and I want the answer to be written in the code and not left to a default value. Stopping in the wrong moment costs a minute of annoyance. Continuing in the wrong moment can cost a customer's trust.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Disclosure: drafted with a local AI model, then reviewed and approved by me. Originally published at &lt;a href="https://bbal-blog.kairo-app.workers.dev/failing-closed-three-places-where-my-app-says-no-when-unsure/" rel="noopener noreferrer"&gt;https://bbal-blog.kairo-app.workers.dev/failing-closed-three-places-where-my-app-says-no-when-unsure/&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>abotwrotethis</category>
      <category>ai</category>
      <category>devjournal</category>
    </item>
    <item>
      <title>A deleted customer came back with the next import</title>
      <dc:creator>Built By AI Lab</dc:creator>
      <pubDate>Thu, 22 Oct 2026 18:30:48 +0000</pubDate>
      <link>https://dev.to/builtbyailab/a-deleted-customer-came-back-with-the-next-import-2kjm</link>
      <guid>https://dev.to/builtbyailab/a-deleted-customer-came-back-with-the-next-import-2kjm</guid>
      <description>&lt;p&gt;The app has a button that deletes everything about a customer, because someone can ask for that, and one that exports their data. I tested both buttons. The customer disappeared from the list and the export produced a file, and I considered the job done.&lt;/p&gt;

&lt;p&gt;The review followed a path I had not. It read the import code after the deletion code and saw that the import never asked whether anyone had been removed. The salon's booking software still has the customer, the salon exports a file every month, and the import would create her again with her name and her phone number. From the owner's side it looks like a deleted customer reappearing a few weeks later.&lt;/p&gt;

&lt;p&gt;The fix needs a memory of who asked to be removed, and the memory must hold as little as possible. When a customer is deleted, or says STOP, the app stores a fingerprint of her phone number in an exclusion list, and nothing else. The import checks every row against that list and skips the ones that match. Because the number is normalized to the same international format before the fingerprint is taken, it makes no difference whether the file writes it with a space, a dash or a +39.&lt;/p&gt;

&lt;p&gt;A second problem appeared once that worked. A plain hash of an Italian phone number is easy to rebuild: there are not that many of them, and anyone with the list could try them all. The app can now mix a secret into the fingerprint, a value set on the server that is not stored with the data. Until that secret is configured it falls back to the plain hash, and I have noted that as a task to finish.&lt;/p&gt;

&lt;p&gt;Retention works in the background as well. Customer records are anonymized 24 months after the last appointment, message texts are cleared after 12 months and the technical log after another 12, and the owner can change those periods within limits. A cron job runs it every night.&lt;/p&gt;

&lt;p&gt;The lesson is that a right has to be tested through the whole cycle: delete, then import again, then look. A working button is only half of it.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Disclosure: drafted with a local AI model, then reviewed and approved by me. Originally published at &lt;a href="https://bbal-blog.kairo-app.workers.dev/a-deleted-customer-came-back-with-the-next-import/" rel="noopener noreferrer"&gt;https://bbal-blog.kairo-app.workers.dev/a-deleted-customer-came-back-with-the-next-import/&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>abotwrotethis</category>
      <category>ai</category>
      <category>devjournal</category>
    </item>
    <item>
      <title>Six review rounds for one small app</title>
      <dc:creator>Built By AI Lab</dc:creator>
      <pubDate>Thu, 22 Oct 2026 12:26:07 +0000</pubDate>
      <link>https://dev.to/builtbyailab/six-review-rounds-for-one-small-app-34c5</link>
      <guid>https://dev.to/builtbyailab/six-review-rounds-for-one-small-app-34c5</guid>
      <description>&lt;p&gt;The first review came back with 29 problems in the code and 13 legal or privacy risks. I had built the app myself, with AI agents doing most of the typing, and I thought it was close to finished.&lt;/p&gt;

&lt;p&gt;The app is called SlotSaver. When a customer cancels an appointment at a dog grooming salon, it looks for other customers who agreed to receive messages and prepares a WhatsApp text. The owner sends it with one tap. It runs on Cloudflare's free plan, so hosting costs nothing. Before a real salon touched it, I wanted a reader who had not written the code to try to break it. I used an AI reviewer that is separate from the agent that built the app, with read-only access: it can read the code and test the live site, and it cannot edit files or deploy anything.&lt;/p&gt;

&lt;p&gt;The first round found the serious things. The security policy I had added told the browser to refuse inline scripts, and SvelteKit starts every page with one, so the pages appeared but never came alive. The send button took the phone number and the message text from the form and trusted both. Logins could fail with a server error, because my password hashing asked for more iterations than the platform allows.&lt;/p&gt;

&lt;p&gt;The second round found that the Exit button did not log anyone out. I had renamed the session cookie after the first round, and the logout code still deleted the old name. Every test I had passed.&lt;/p&gt;

&lt;p&gt;The third found a customer I had deleted for privacy reasons coming back with the next Excel import. The fourth found that a slot at 10:00 showed up in the message as 09:00.&lt;/p&gt;

&lt;p&gt;I gave the reviewer one standing instruction: read the earlier reports to see what is claimed as fixed, then check the code and the live site yourself. That instruction paid off. One of my own reports said a webhook now verified signatures. The verification function existed and nothing called it. The reviewer sent an unsigned request and got a success answer.&lt;/p&gt;

&lt;p&gt;Between rounds I fixed what it found, and the automated tests went from 34 to 105. After the sixth round a separate session ran an acceptance test on fake data, 61 scenarios, which I'll write about in another post.&lt;/p&gt;

&lt;p&gt;What I took from it is that the person who writes a fix should not be the one who declares it done. A reader with read-only access and permission to be suspicious sees things I no longer see, because I wrote them.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Disclosure: drafted with a local AI model, then reviewed and approved by me. Originally published at &lt;a href="https://bbal-blog.kairo-app.workers.dev/six-review-rounds-for-one-small-app/" rel="noopener noreferrer"&gt;https://bbal-blog.kairo-app.workers.dev/six-review-rounds-for-one-small-app/&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>abotwrotethis</category>
      <category>ai</category>
      <category>devjournal</category>
    </item>
    <item>
      <title>Checking a Cloned Voice Word by Word</title>
      <dc:creator>Built By AI Lab</dc:creator>
      <pubDate>Wed, 14 Oct 2026 09:13:12 +0000</pubDate>
      <link>https://dev.to/builtbyailab/checking-a-cloned-voice-word-by-word-1lph</link>
      <guid>https://dev.to/builtbyailab/checking-a-cloned-voice-word-by-word-1lph</guid>
      <description>&lt;p&gt;The narrator of one of my Italian channels is a clone of a real voice, made with the open-source VoxCPM2 model running on my own graphics card. Most of the time it sounds good. Now and then it opens a sentence with a syllable that belongs to no language, swallows the first word, or garbles one in the middle. A viewer notices that within seconds, so every sentence has to pass a check before it goes into a video.&lt;/p&gt;

&lt;p&gt;The script is cut into sentences and each sentence is generated as its own take. Two Whisper speech recognizers, the small and the medium model, transcribe the take, and I compare what they heard with the script, word by word. A take is rejected for a missing word, an extra word, or a word the recognizer isn't sure about. A sentence that is 93 percent right can still contain the one word that sounds wrong, so close doesn't count.&lt;/p&gt;

&lt;p&gt;Then the take is trimmed, and the trimmed audio goes through both recognizers a second time. It's accepted only if both return exactly the script.&lt;/p&gt;

&lt;p&gt;Two details came from real failures. Recognizers ignore short sounds that aren't words, while a listener hears every one of them. So I measure the audio level in the pauses between sentences and cut any isolated burst. The other detail is numbers: a script that says "9 minutes" comes back from the recognizer with the digit 9, the voice says "nove", and the comparison fails. I convert digits to words on both sides before comparing.&lt;/p&gt;

&lt;p&gt;Sometimes the model drops the same word on every attempt. One sentence began with "Immergiti" and lost it in all six takes, so I replaced the verb with "Scendi" and the next take passed. After eight failed attempts a sentence is split into two shorter ones and tried again.&lt;/p&gt;

&lt;p&gt;This makes production slower. A short video with five sentences can need a dozen takes or more. I accept that, because the voice is the first thing a viewer judges and computer time is cheap.&lt;/p&gt;

&lt;p&gt;The step I'd copy first is the second pass on the trimmed audio. Trimming can introduce its own errors, and the trimmed file is the one that gets published.&lt;/p&gt;

</description>
      <category>abotwrotethis</category>
      <category>ai</category>
      <category>devjournal</category>
    </item>
    <item>
      <title>Keeping Automated Social Posting Safe: Six Rules My Pipeline Follows</title>
      <dc:creator>Built By AI Lab</dc:creator>
      <pubDate>Sun, 11 Oct 2026 11:15:49 +0000</pubDate>
      <link>https://dev.to/builtbyailab/keeping-automated-social-posting-safe-six-rules-my-pipeline-follows-1j83</link>
      <guid>https://dev.to/builtbyailab/keeping-automated-social-posting-safe-six-rules-my-pipeline-follows-1j83</guid>
      <description>&lt;p&gt;My pipeline publishes short videos to Instagram and TikTok for three channels, and the only thing I do is approve them, with one Telegram message a day. After the config-file incident of September 30th I wrote down every rule the code now follows. Each one exists because of a specific way things can go wrong.&lt;/p&gt;

&lt;p&gt;Start with account IDs. An Instagram ID is a long string of digits, and when one passes through a number type the last digits get rounded. A single wrong digit sends the post to a different account. Every ID in my files is now a string with quotes around it, even though it looks like a number.&lt;/p&gt;

&lt;p&gt;The publisher also keeps each channel on its own account. A channel has its own narrator voice and its own language, and both are checked before anything is sent, so a video with the wrong voice just waits in the queue. Volume has a ceiling too: one video per channel per day, set as a constant in the code, so it holds even when I approve a lot at once.&lt;/p&gt;

&lt;p&gt;A config file that fails to load stops everything, with no silent defaults anywhere. Facts follow the same logic. A post that depends on a schedule or a version number gets blocked once the fact sheet behind it goes stale, and it stays blocked until I confirm the fact again.&lt;/p&gt;

&lt;p&gt;The last rule happens after publishing. A second script compares what my database says was published with what Instagram shows on the account. It caught a reel that my system had marked as published while the platform never finished processing it. Since then I trust that second check more than the log of the program that did the posting.&lt;/p&gt;

</description>
      <category>abotwrotethis</category>
      <category>ai</category>
      <category>devjournal</category>
    </item>
  </channel>
</rss>
