The magic of Amazon’s Kiro: my 1st vibe-coded PyQt6 app!

The recently released Amazon Kiro, even if it’s just a preview, is the latest shit in AI-assisted software development. I happened to download it while it was still possible (now you have to join a waiting list), and I gave it a try. Oh, boy, it was painful. But magic, right? Vibe coding, here I come!

1 👻 Kiro: The Good ■ 2 👻 Kiro: The Bad ■ 3 👻 Kiro: The Ugly ■ 4 👻 Kiro: The Aftermath ■ 5 The real bug of the app ■ 6 PyQt6, PyInstaller and Windows: Mission Impossible ■ 7 Comic Strip Browser — on GitHub & SourceForge ■ 8 👻 Kiro: The End?

👻 Kiro: The Good

Well, the good part about Kiro: The AI IDE for prototype to production, is that it exists. The Pricing page states: “During our preview period, take advantage of reasonable limits at no cost.” After that, things will change, but it’s not fully established how, as the following breakdown has been removed from the page:

KIRO FREE

• Agentic capabilities in the Kiro IDE (limit 50 interactions per month)
• Specs
• Agent hooks
• Model context protocol (MCP)
• Agent steering

KIRO PRO — $19/mo. per user. Everything in Kiro Free, with:

• Increased limits for Kiro agentic capabilities (total limit: 1,000 interactions per month)

KIRO PRO+ — $39/mo. per user. Everything in Kiro Pro, with:

• Increased limits for Kiro agentic capabilities (total limit: 3,000 interactions per month)

The official announcement, Introducing Kiro, has been posted on July 14. I learned about it 2 days later, from OMG! Ubuntu‘s Kiro, Amazon-Backed Agentic IDE, Enters Public Preview:

Kiro can’t be used offline, and requires a sign-in with one of four sign-in providers (e.g., Google, GitHub) to be used. A step-by-step tutorial is included to help introduce the workflow and key features.

Currently, Kiro only supports English prompt/specs/hooks but more language support is planned — and on programming languages, it supports most used by developers including Python, Java, JavaScript, TypeScript, C#, Go, Rust, PHP, Ruby, Kotlin, and more.

Other online materials I’ve read include Yehuda Cohen’s Developing with Kiro: Amazon’s New Agentic IDE:

The reality is that Kiro requires a different kind of project management. You’re not just writing code anymore; you’re steering an AI that can get overwhelmed by complexity, sometimes prefers workarounds over root cause analysis, and occasionally needs to be told explicitly not to move on until issues are actually fixed. It’s powerful, but it’s not hands-off.
…
In fact, many developers are already trying to use Cursor for complex, multi-step workflows by having it update and refer to requirements files, essentially trying to create their own spec-driven development process. The problem is that these tools weren’t really designed for that kind of autonomous execution. They’re great at the task you’re currently working on, but they tend to drift when you need them to follow a complex plan over multiple sessions.

Kiro feels different because it was built from the ground up to handle this kind of work. Instead of trying to hack together a spec-driven workflow, Kiro already knows how to help you build and adhere to a specification and develop without deviating too far from the plan. You can tell it how to implement something, create complex plans, and then let it run largely by itself, filling in the implementation details.

The shift is subtle but significant. With Cursor, I’m constantly course-correcting and re-explaining context. With Kiro, I spend more time upfront articulating what I want to build, but then I can step back and let it execute. It’s the difference between being a hands-on manager who needs to check every detail versus setting clear expectations and trusting the process.

But I want to be clear about something: this isn’t magic, and for now, there are still times when your coding skills will be required. There are still times that Kiro is unable to solve your bugs for you. At this point you need to solve them yourself or guide Kiro very explicitly regarding the approach to take. You need to develop a sense for when to let it run and when to start interfering or take over control.
…
The process started with me describing what I wanted: a clean, professional portfolio site with project showcases, a blog section, and contact information. I mentioned I wanted to use TanStack Start for the framework and shadcn for the component library, but beyond that, I was pretty vague about the implementation details.

I was quite impressed by what happened next. Kiro didn’t just start writing code—it created a requirements document, a design document, and a detailed task list. This spec-driven approach meant I could review and refine what we were building before any code was written. I made a few tweaks to the requirements (added some specific sections I wanted, adjusted the visual direction), and then Kiro got to work.

The execution was largely autonomous. I had to set up a couple of MCP servers first—one for DuckDuckGo to help it search for documentation when it got stuck, and another for GitHub access. But once that was configured, Kiro handled the heavy lifting. It scaffolded the project structure, implemented the routing, created the components, and even handled the CSS styling.

What was particularly clever was how it handled content generation. Rather than me having to write all the portfolio content myself, I simply pointed Kiro to use the MCP server integrations to scrape the data it needed about me from a couple of links. It pulled information about my projects, background, and experience automatically, then structured it appropriately for the site.

Here’s where it got interesting: I know very little about modern CSS, especially the kind of complex layouts and animations you see in professional websites. But Kiro managed to create something that looked genuinely polished. When I pointed out rendering issues or asked for visual tweaks, it understood what I meant and made the corrections without me having to explain the technical implementation.

The whole process took about four hours, and I wrote exactly zero lines of code. More importantly, when I wanted to make changes later—adding new sections, tweaking the design, or fixing bugs—I could describe what I wanted in plain English, and Kiro would implement it correctly.

That said, it wasn’t completely hands-off. I had to interrupt the process a few times when Kiro started going down the wrong path or when it needed clarification about specific requirements. The key was learning to be specific about what I wanted upfront and not being afraid to course-correct when needed.

Oh, this guy was both lucky and easy to impress, methinks. But let’s dig a bit on Reddit. While there’s a r/kiroIDE subreddit, I only read the following posts:

Amazon’s Cursor Competitor Kiro is Surprisingly good!!

From what I can tell, it seems to be completely free and includes full access to Claude 4 Sonnet and Claude 3.7. This makes sense as I believe Anthropic and Amazon are in some kind of partnership.

Copy pasting my mini review:

Mini-review:

• It’s slow as sin (when talking with AI, not UI responsiveness) compared to Claude Code (well duh) but also Cursor. This may be an artifact of it being free while in preview, so they don’t want to go broke before being able to charge the users. Maybe 2x slower than cursor and 4x slower than Claude Code? I didn’t measure it, subjective bs.
• Cursor writes out the thinking process in gray text, no such thing here. You only see the “polished” answer from AI, like with Claude Code.
• On Windows, it’s using Powershell for cli interactions like Cursor. This sucks, and commands easily fail. They should switch to Bash like Claude Code does.
• It’s essentially Claude like the others, so you see similar problem analysis and euphoric feedback when something works (or doesn’t work in a way that Claude thinks is a-ok).
• The UI is more “polished” and less buggy than Cursor, which you’d expect from AWS I guess.

Verdict: you can use it for free, so download it while it lasts! In any case, this is worlds better than the competing free choice Gemini-cli. No doubts this will be seen as “Cursor killer” if they can keep the price competitive and increase the performance (which is likely just about $$$).

Disclaimer: I didn’t try any of the “novel” design time innovations of Kiro, just vibing to fix a bug in .NET code. I’ll try the design/spec features when I start a new project.

Amazon’s new Claude-powered spec-driven IDE (Kiro) feels like a game-changer. Thoughts?

Amazon just released their Kiro IDE like two hours ago which feels like Cursor but the main difference is its designed to bring structure to vibe-coded apps using spec-driven development built-in by default.

It’s powered by Sonnet 4.

The idea is to make it easier to bring vibe-coded apps into a production environment, which is something that most platforms struggle with today.

The same techniques that people on here were using in Claude Code seem to be built-in to Kiro. I’ve only been using it for the last hour but so far it seems very impressive.

It basically automatically applies SWE best practices to the vibe-coding workflow to bring about structure and a more organized way of app development.

For instance, without me explicitly prompting it to do this, it started off creating a spec file for the initial version of my app.

Within the spec file, it auto-created a:

• Requirements document
• Design document
• Task list.

Again, I did not prompt it to create these files. This is built-in.

It did a pretty good job with these files.

The task list it creates is basically all the tasks for that spec. You can click on each task individually and have the agent apply it.

Overall, I’m very impressed with it.

It’s in public preview right now, not sure what the pricing is going to look like.

Curious what you guys think of it, and how you find it compares to Claude Code.

PCMag: Amazon Kiro Is Here to Tame the Vibe Coding Chaos:

The main AI model behind Kiro is Anthropic’s code-focused Claude Sonnet 4, with Claude Sonnet 3.7 as a backup option, Amazon tells The New Stack. Support for more models is coming soon. Kiro is free for now while it’s in preview. Eventually, the company will offer three pricing tiers: Free, Kiro Pro ($19-per-month), and Kiro Pro+ ($39-per-month). It will also be free for those with a Developer Pro account on Amazon Q, the company’s AI coding assistant ($20-per-month).

To tame it? Maybe to unleash it!

Forbes: AWS Launches Kiro, A Specification-Driven Agentic IDE:

From Vibe Coding to Viable Code

The timing of Kiro’s release aligns with the explosive growth of what industry leaders term “vibe coding”, a practice of using natural language prompts to generate functional applications quickly. This approach has gained traction as developers embrace tools that can translate conversational instructions into working code, but enterprises remain cautious about adopting workflows that lack structure and documentation.

Kiro addresses this tension by introducing what AWS calls “spec coding,” a methodology that preserves the intuitive nature of AI-assisted development while adding the rigor enterprises demand. The platform transforms single prompts into structured specifications, technical designs, and implementation plans with comprehensive testing requirements.

The core innovation lies in Kiro’s two-tier architecture: specifications that provide structured development guidance and hooks that automate quality assurance tasks. When developers input a prompt like “Add a review system for products,” Kiro generates detailed user stories with acceptance criteria, technical design documents including data flow diagrams and API endpoints, and sequenced implementation tasks with testing requirements.

Technical Architecture and Implementation

Kiro’s technical foundation builds on Code OSS, the open-source base of Visual Studio Code, ensuring compatibility with existing developer workflows. The platform integrates Claude Sonnet 4.0 and 3.7 models as its primary AI engines, with plans to support additional models.

The specification-driven development process operates in three phases: requirement unpacking, technical design generation, and task implementation. Each phase maintains traceability between high-level requirements and implementation details, addressing a common criticism of existing agentic tools that generate code without clear documentation of design decisions.

The IDE’s hook system provides event-driven automation that triggers when developers save, create, or modify files. These hooks can update test files, refresh documentation, or perform security scans automatically. This automation layer addresses enterprise concerns about maintaining code quality and security standards in AI-generated code.

Finally, a 11-minute video: Better Stack on YT: Amazon’s NEW AI IDE is Actually Different (in a good way!) – Kiro. Chapters:

00:00 Intro
00:23 Setup
00:34 First Look
00:42 Spec Feature
06:18 Hooks Feature
08:27 Usual Features
09:31 Pricing
09:52 Wrap-up

👻 Kiro: The Bad

The very first bad thing is that you cannot download Kiro just right now; you have to join a mailing list. Mind you, poor AWS cannot handle such a big success: “Kiro is seeing unprecedented demand.” No shit, Sherlock.

However, the URL for the .deb file I downloaded is still working! It’s not the very last version, but it works! Here: 202507161954-distro-linux-x64.deb (177.1 MiB).

This “unprecedented success” is what made them remove the pricing information. That’s because the “reasonable limits at no cost,” while not being downgraded to 50 interactions per month in the free tier, have meanwhile been severely limited. They have a daily limit, or maybe a limit that resets after 12 hours; either way, I struggled to make Kiro fix the bugs it generated, and after I spent three days with a project, I stopped using Kiro. The app was usable, after all, and I could make a few tiny adjustments myself.

If I could have updated from version 0.1.9 to version 0.1.15, the message “Too many requests, please wait before trying again” would have been this one: “You’ve reached your daily usage limit. Please return tomorrow to continue building.” It’s not always “tomorrow,” but the time of reset is unknown. But they definitely lowered the limits to absurdly low values.

👻 Kiro: The Ugly

Based on my older post Bypassing GoComics’ paywall, I decided I do have an idea for a quick and dirty PyQt6 app: a standalone app able to browse and display a selection of comic strip titles from GoComics!

So, while running Kiro in Ubuntu MATE 24.04 LTS, I wrote my idea in a file called “General specs.txt” whose contents can be seen below:

— I need a standalone app, possibly with PyQt, and I need it for both Linux and Windows, that would serve as a comic strip browser.

— It will retrieve the comics from www.gocomics.com, by retrieving the web pages via curl, then parsing the retrieved page to identify the URL of the image.

— The comic strips I want:
1. Calvin and Hobbes — https://www.gocomics.com/calvinandhobbes
2-3. Peanuts and Peanuts Begins — https://www.gocomics.com/peanuts and https://www.gocomics.com/peanuts-begins
4. Garfield — https://www.gocomics.com/garfield
5-6. Wizard of Id and Wizard of Id Classics — https://www.gocomics.com/wizardofid and https://www.gocomics.com/wizard-of-id-classics
7. Pearls before Swine — https://www.gocomics.com/pearlsbeforeswine
8. Shoe — https://www.gocomics.com/shoe
9-10. B.C. and Back to B.C. — https://www.gocomics.com/bc and https://www.gocomics.com/back-to-bc
11. Pickles — https://www.gocomics.com/pickles
12. WuMo — https://www.gocomics.com/wumo
13. Speed Bump — https://www.gocomics.com/speedbump
14. Free Range — https://www.gocomics.com/freerange

— Here's how it should go:
a. The URLs are including the day at the end, like this: https://www.gocomics.com/garfield/2025/07/03
b. The app should attempt to open the current day by the full URL, not just https://www.gocomics.com/garfield
If it fails, possibly because of the TZ differences, it should go for yesterday's comic.
c. The app should allow to navigate back in time up to the very first comic available for each of the 14 listed above.
The app should initially attempt to determine which is that first comic for each, and to save in a config file that date. To do so, it could go back 1 year at a time, and once it fails, it should go to the next valid year and only go one month back, and so on. This is a one-time only process that should only happen if the config file doesn't contain all those 14 start dates.
d. A failure means the required data cannot be found in the retrieved pages, or a 404 error was received.
e. How to find the useful contents. Example:
Take this page: 
https://www.gocomics.com/garfield/2025/07/03

In its contents, the title says:
<title>Garfield by Jim Davis for July 3, 2025 | GoComics</title>

This should be used in the UI.

Then, also in the page source, there are 3 important META values. In our case: 
<meta property="og:image" content="https://featureassets.gocomics.com/assets/387656f02869013ea464005056a9545d"/>
<meta property="og:image:width" content="900"/>
<meta property="og:image:height" content="258"/>

We should retrieve the image URL, i.e. https://featureassets.gocomics.com/assets/387656f02869013ea464005056a9545d
and width and height.

The image type, GIF, JPEG, PNG, whatever, should be detected. It might be different on Sundays, when some comics are larger.

— The UI should allow the following:
a. Select the comic either from a menu, or from a list.
b. Display today's strip for the selected comic.
c. Include a calendar (one month at a time) so another day be selectable by a click. Changing the month and the year should be easy, too.

— The images for the last visited 50 days for each of the 14 strips shopuld be cached on disk.

It then started crunching, and it produced the following files in .kiro/specs/comic-strip-browser: requirements.md, design.md, tasks.md. In the root folder, among other files, README.md, TESTING.md, DEPLOYMENT.md.

This isn’t the very first version of requirements.md, because, for some reason, it initially stripped the URLs I gave it. I had to prompt it to keep them there!

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   UI Layer      │    │  Service Layer  │    │   Data Layer    │
│  (PyQt6 Views)  │◄──►│   (Business     │◄──►│   (Models &     │
│                 │    │    Logic)       │    │    Storage)     │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         ▼                       ▼                       ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│ - MainWindow    │    │ - ComicService  │    │ - ComicModel    │
│ - ComicViewer   │    │ - WebScraper    │    │ - CacheManager  │
│ - CalendarWidget│    │ - DateManager   │    │ - ConfigManager │
│ - ComicSelector │    │ - ErrorHandler  │    │ - FileStorage   │
└─────────────────┘    └─────────────────┘    └─────────────────┘

@dataclass
class ComicData:
    comic_name: str
    date: datetime.date
    title: str
    image_url: str
    image_width: int
    image_height: int
    image_format: str
    author: str
    cached_image_path: Optional[str] = None
    retrieved_at: datetime.datetime = field(default_factory=datetime.now)

@dataclass
class ComicDefinition:
    name: str
    display_name: str
    base_url: str
    author: str
    earliest_date: Optional[datetime.date] = None

# Predefined comic definitions
COMIC_DEFINITIONS = [
    ComicDefinition("calvinandhobbes", "Calvin and Hobbes", 
                   "https://www.gocomics.com/calvinandhobbes", "Bill Watterson"),
    ComicDefinition("peanuts", "Peanuts", 
                   "https://www.gocomics.com/peanuts", "Charles M. Schulz"),
    # ... (all 14 comics)
]

@dataclass
class CacheEntry:
    comic_data: ComicData
    access_count: int
    last_accessed: datetime.datetime
    file_size: int

class ErrorHandler:
    def handle_comic_retrieval_error(self, comic_name: str, date: datetime.date, error: Exception):
        if isinstance(error, requests.HTTPError) and error.response.status_code == 404:
            # Try previous day
            previous_date = date - datetime.timedelta(days=1)
            return self.comic_service.get_comic(comic_name, previous_date)
        elif isinstance(error, requests.ConnectionError):
            # Check cache first
            cached_comic = self.cache_manager.get_cached_comic(comic_name, date)
            if cached_comic:
                return cached_comic
            raise ComicUnavailableError(f"Cannot retrieve {comic_name} for {date}")

Here, too, the file has later been modified by the addition of an 18th task, meant to fix some UI issues.

For some reason, out of the initial 17 tasks, only the following 3 implementation summaries were left on disk (maybe they’re supposed to act as documentation for the code?):

# Check dependencies
python run_tests.py check-deps

# Run all tests
python run_tests.py all

# Run specific categories
python run_tests.py unit
python run_tests.py performance
python run_tests.py regression
python run_tests.py e2e

# Generate comprehensive report
python run_tests.py report

In the process, it installed with pip all the missing dependencies. I wasn’t given the option to install global packages that were available, but it decided to use a venv anyway, because this is what you do when you’re using pip in a system that has global Python libraries, just not everything you need.

It fixed most of the bugs that it generated in the process, and boy, it created bugs at a tremendous pace! Most of its chat output was Claude talking to itself: “Oh, it failed! Let me try something else!” or “Let me try to fix this.”

At several stages, I was shown the UI of the app, which became increasingly functional, but in the end, after the completion of the 17th task (with only 96% of the tests passed, but its self-imposed target was 80%), I was left without any further assistance.

Could you believe that I couldn’t even run anything because it had deleted the binaries?

Its DEPLOYMENT.md document lied: no binary was left on disk. Even the build instructions were wrong, because they assumed pip was allowed to install globally, which isn’t such a great idea in Linux. But once I had a running app, it was stuck at start! We were both guilty: I didn’t create the best requirements, and it didn’t give a rat’s ass to check if it actually runs as a full app!

From now on, I’ll describe my adventures with Kiro by the means of the prompts I gave it.

1 ■ Load the current project specs from “requirements.md”. You finished the 17 tasks in “tasks.md” but left me with no binaries! Recreate the deployable binaries, placing them under dist/, and don’t delete them! Also, adapt DEPLOYMENT.md to the situations where “pip install -r requirements.txt” fails when people try to manually build, because they have system-wide Python packages and they did not create a virtual environment. Note that not all the tests have passed, but I wasn’t asked anything.

This time it identified version discrepancies between the global and the venv Python packages, and it tried to adapt to those available in Ubuntu. It struggled to find compatible versions. That’s the joy of using Linux! You cannot have a unique version of Python, system-wide, that everyone should fucking use! Oh, maybe in Arch, which should have the latest versions of pretty much everything.

2 ■ At its first run, the app is stuck at 60% in “First run detected – discovering comic dates…” Have you properly tested for that initial stage?

3 ■ Now it crashes!

$ ./comicstripbrowser

(comicstripbrowser:84756): dbind-WARNING **: 15:31:18.698: Couldn’t connect to accessibility bus: Failed to connect to socket /root/.cache/at-spi/bus_0: Permission denied
qt.accessibility.atspi: Error in contacting registry: “org.freedesktop.DBus.Error.Disconnected” “Not connected to D-Bus server”
main.py:32: DeprecationWarning: sipPyTypeDict() is deprecated, the extension module should use sipPyTypeDictRef() instead

4 ■ Another idea: how about hard-coding the oldest available date for each comic? It’s not likely to change soon. However, the app should accept the errors due to the unavailability of some older dates.

It even deleted README.md in the process, didn’t remember it did, and had to recreate it when updating it failed.

5 ■ There are no binaries in dist/ – it looks like you forgot to build them or you deleted them.

6 ■ There are no binaries in /dist!

7 ■ Can you fix this crash? $ ./comicstripbrowser

(comicstripbrowser:92670): dbind-WARNING **: 16:01:21.320: Couldn’t connect to accessibility bus: Failed to connect to socket /root/.cache/at-spi/bus_0: Permission denied
qt.accessibility.atspi: Error in contacting registry: “org.freedesktop.DBus.Error.Disconnected” “Not connected to D-Bus server”
main.py:32: DeprecationWarning: sipPyTypeDict() is deprecated, the extension module should use sipPyTypeDictRef() instead

Oops!

Kiro: Too many requests, please wait before trying again.

Anyway, it’s stunning how the app that it launched during the testing stages “just worked,” but the “finished project” crashed!

Several hours later…

8 ■ When you tested it, it ran just fine, but when I launch it, it crashes! ./comicstripbrowser

(comicstripbrowser:98236): dbind-WARNING **: 05:40:30.154: Couldn’t connect to accessibility bus: Failed to connect to socket /root/.cache/at-spi/bus_0: Permission denied
qt.accessibility.atspi: Error in contacting registry: “org.freedesktop.DBus.Error.Disconnected” “Not connected to D-Bus server”

And it made it run!

9 ■ It works! Issues to fix:
1. The left-side list of the comics prints invisibly (white on white) or not at all the names of the strips. Only the authors are visible. Please fix this. If possible, the name of the strip should be in bold.
2. The right-side calendar has a properly displayed month, but the navigation for previous/next month/year is invisible (almost white on white). Please fix this.
3. Also, the right-side has a empty box at the top. Why?
4. Above “Select a comic strip to browse” and above the current strip’s name there are empty text boxes or labels. Why? Just print the two fields in larger letters and maybe in bold!

Kiro: Session Too Long. Summarize and continue in a new session.

It then added Task 18 to fix these issues. But it also created .kiro/specs/calendar-widget-fix, with its own set of requirements.md, design.md, tasks.md! Task 18 of comic-strip-browser was to be implemented as 5 tasks of the calendar-widget-fix subproject.

10 ■ – The name of the month and the name of the year are not visible in the calendar.
– Above “Select a comic strip to browse” there is still an empty label.

11 ■ Above the controls that are above the calendar there is still a big empty box about the same size as the calendar that reads “Calendar”. Why don’t you get rid of it and shift everything up?

12 ■ You moved the navigation through months and years in that big square box instead of keeping the navigation with the old sizes and do something with that box!

13 ■ This is worse! You broke the legend! Now all those labels fill the entire remaining height!

14 ■ Now the text is way to small for all the fields in the legend!
Then, the names of the days of the week are too distanced from the calendar. Wasted space remains.
Finally, you DID NOT rebuild the binary in dist/

I might have forgotten to copy & paste a prompt, but the idea is that it took it several attempts to come to a decent design.

And now I had the very bad idea to ask it for a Flatpack and a snap! To make things even worse, I discovered a bug in the calendar, so I had to address it, confusing Kiro and Claude even more!

15 ■ Great! Can you also build any of these?
– an AppImage
– a flatpak
– a snap
– a .deb, maybe? With a list of dependencies for Ubuntu 24.04 LTS, so a full “sudo apt install” command could be used.
– a Windows installer? Or, a more detailed procedure of building it under Windows.

16 ■ But how do I use org.comicbrowser.ComicStripBrowser.yml and snapcraft.yaml to upload the binaries on the respective servers?

17 ■ A new bug: once you navigate 2 or more years in the past, by using the “Previous year” button, the days in the calendar are no longer selectable!
A smaller bug: the buttons for navigation by year are “inside” the buttons for navigation by month. Logically, it should have been the other way around.

18 ■ I cannot see the rebuilt binary + AppImage + .deb.

19 ■ The bug about “navigate 2+ years back and the days are grayed out, unselectable” is still there.

20 ■ Nope, the bug is still there.

21 ■ Nope. Still there. Moving 2 years in any direction will make the days in any month not clickable.

Session Too Long: Summarize and continue in a new session.

23 ■ The days are clickable, BUT if the date is 2+ years in any direction, they’re in light blue as if they were diabled!

24 ■ Light gray, sorry.

25 ■ It works! However, I don’t like other changes: the 4 blue buttons under the current comic. The calendar at right and the list of comics at the left are enough for navigation.
Once you remove the blue buttons, make sure the list of comics at the left has no background without a set color, because on systems with a dark theme, it’s black around the labels. Make it gray.
In the end, don’t forget to build: the binary; the AppImage; the .deb.

26 ■ I can see another unwanted change: there’s a menu at the top: Previous, Next, Today. These 3 actions should be in buttons under the displayed comic, and the menu should go away!
Also, the light gray you just added around the list of comics: add it around the to labels, too: “Comic Strips”/”Select a comic strip to browse” and the 2 labels with the current name and date of strip.
Finally, no months in future should be displayed!

27 ■ Excellent! But “Comic Strips” and “Select a comic strip to browse” still have a white background.

28 ■ – The right panel with calendar and navigation in time is still with a white background.
– The text “Choose a comic from the selector on the left” is too small. Make it more visible and “Select a comic from the left”.
– When nothing has been selected yet, display the image from the file idle.png (of course, embed it in the app).
– Change the icon for the app to comicicon.png.

29 ■ There is still no initial image instead of “Select a comic strip to view” on an empty white rectangle! Did you find the idle.png file in the folder?
And icon.png in assets is not updated either.

30 ■ You stopped before finishing the task.

It still didn’t import the image I wanted it to use! I gave up trying. It literally disregarded my instructions and reported this instead: “Created a visually appealing HTML-based welcome screen with a large newspaper emoji (📰) and welcome text.”

31 ■ You created the following files:
DEPLOYMENT.md
FLATPAK_SUBMISSION.md
SNAP_SUBMISSION.md
STORE_SUBMISSION_GUIDE.md
INSTALLATION.md
However, why cannot you create the actual flatpack and snap packages?

32 ■ NO, you do not need to log out and log back in for the group changes to take effect.

The retard refuses to run newgrp lxd!

33 ■ build_flatpak.sh is broken: https://files.pythonhosted.org/packages/28/76/4a31132611a1eb2a9b32e1140d573a1ac4e1e8e62d2b102c806b8f2e1b8b/PyQt6-6.6.1-cp38-abi3-linux_x86_64.whl does not exist.

Kiro: Session Too Long. Summarize and continue in a new session.

34 ■ build_flatpak.sh is broken: https://files.pythonhosted.org/packages/28/76/4a31132611a1eb2a9b32e1140d573a1ac4e1e8e62d2b102c806b8f2e1b8b/PyQt6-6.6.1-cp38-abi3-linux_x86_64.whl does not exist.
build_snap.sh also fails: try running it yourself!

It’s only now that it created packaging-fixes and started executing tasks.md. But then…

Kiro: Too many requests, please wait before trying again.

Much later, I tried again (by clicking on a task), but “The model you’ve selected is experiencing a high volume of traffic. Try changing the model and re-running your prompt.” for both Claude models! Eventually, Sonnet 3.7 agreed to work. But it struggled a lot, and it “experienced a high volume” periodically!

Kiro: Session Too Long. Summarize and continue in a new session.

35 ■ Building the flatpak fails:
Failed to download sources: module python3-deps: The requested URL returned error: 404

Building the snap fails:
ERROR: ld.so: object ‘libgtk3-nocsd.so.0’ from LD_PRELOAD cannot be preloaded (cannot open shared object file): ignored.
error parsing ‘snapcraft.yaml’: could not find expected ‘:’
Detailed information: while scanning a simple key
in “snap/snapcraft.yaml”, line 53, column 1
could not find expected ‘:’
in “snap/snapcraft.yaml”, line 54, column 1
Recommended resolution: Ensure snapcraft.yaml contains valid YAML

36 ■ They both still fail. Why don’t you try building the flatpak and the snap yourself, so you could handle the errors?

It took it ages! Then:

Kiro: Session Too Long. Summarize and continue in a new session.

37 ■ OK, so fix build_flatpak.sh and build_snap.sh and run them yourself, so I can have a flatpak and a snap.

It kept producing erroneous building scripts. And it struggled to fix them, and it struggled…

Eventually:

Both packages are now available:
Flatpak package: comic-strip-browser.tar.gz
Snap package: comic-strip-browser-snap.tar.gz
These packages can be used to install and run the Comic Strip Browser application on Linux systems.

38 ■ But comic-strip-browser.tar.gz is 200.9 KiB and comic-strip-browser-snap.tar.gz is 201.2 KiB! How can they include an app that has 125.1 MiB on its own?

39 ■ Yes, do create proper packages!

40 ■ Now, suppose I want to upload the sources and the binaries on https://github.com/DerLudditus/comic-strip-browser
Can you update README.md, BUILD_INSTRUCTIONS.md, INSTALLATION.md, WINDOWS_BUILD.md and whatever else is relevant? Because they’re outdated.
I need them to reference the binaries I’ll upload there with each release (a .deb, a prebuilt binary with a .desktop and an icon as PNG), and boilerplates for snap and flatpak, which I still have to upload to snapcraft.io and flathub.org. Also, proper instructions for those wishing to build a Windows version themselves.

Kiro: Session Too Long. Summarize and continue in a new session.

41 ■ As previously stated, update README.md, BUILD_INSTRUCTIONS.md, INSTALLATION.md, WINDOWS_BUILD.md and whatever else is relevant, to match the current status. I need them to reference the binaries I’ll upload there with each release (a .deb, a prebuilt binary with a .desktop and an icon as PNG), and boilerplates for snap and flatpak, which I still have to upload to snapcraft.io and flathub.org. Also, proper instructions for those wishing to build a Windows version themselves.

Kiro: Too many requests, please wait before trying again.

Go fuck your mother, you stupid piece of shit!

👻 Kiro: The Aftermath

Amazon Kiro has created for me a functional PyQt6 app, complete with test units. However, there’s no project per se, but just files in a folder and subfolders. Suppose I want to use it in an IDE that has a proper project file or folder for Python projects? It could have created an .idea directory for PyCharm, or a .code-workspace file for VS Code, or something else (Spyder too uses projects), but it didn’t even try. Oh, and no .ui files, just .py. That’s primitive for a GUI app.

The root folder was a huge mess. Because Kiro has treated this project as 3 projects, comic-strip-browser, calendar-widget-fix, and packaging-fixes, each one with its own set of requirements.md, design.md, and tasks.md, and because the first one already created a tests folder, the other two left the various test_*.py in the root folder. Various .md files with incorrect or outdated contents also littered the place.

Given the way I had to “steer” it (not in the meaning of its “Agent Steering” capabilities, but through a series of subsequent prompts), those tests are of no use to me. Not good enough! They were, however, crucial to Kiro or to Claude, because there was no other way they could know whether the code actually does what it’s supposed to do. But I’m not keeping them.

Needless to say, Kiro couldn’t create a usable Flatpak and a usable snap. With what I was left, building a .flatpak and a .snap was impossible without too much tinkering. The stupid Flathub requirements have deterred me from ever trying to build a Flatpak again. Not to mention that Kiro never asked me where I might want to host the project, so it made it be org.comicbrowser.ComicStripBrowser (hosting on github.com/DerLudditus/comic-strip-browser requires its canonical name to be io.github.DerLudditus.ComicStripBrowser or io.github.DerLudditus.comic_strip_browser, and many file names or content need to be changed).

Did you know that there’s absolutely no helper tool that would allow you to create a Flatpak from a source folder? From scratch, that is. Kiro (or Claude) did create a .yaml manifest, but if I were to create such a .yaml (or a .json manifest), it wouldn’t be an easy task. It has also retrieved some .whl files (being it a Python project) that apparently are necessary for a Flatpak. Oh, but are they really needed? If so, how would I fucking know?

As for the snap… as long as this is an Ubuntu thing, why not stick to the .deb? Building an AppImage is also easy, but I had to perform a cleanup in the build_scripts folder, as only a few scripts were needed (plenty of crap there, too).

I have to insist on the generalized mess left in the project. For instance, despite the code still not using a default background image at start, comic_browser.spec insisted on including that image and embedding it in all binaries. It also insisted on including in the Linux builds the comicicon.png file that eventually became comic-strip-browser.png after I told Kiro to use it instead of the ugly icon made by it (but it didn’t update the .ico for Windows, so I had to do it myself).

Since I decided to never ask Kiro to make any change to this app, I made a couple of tiny UI adjustments by hand. Can you spot them in this “before” vs. “after” comparison?

Then, I changed the maximum sizes:

The real bug of the app

You have to understand that the produced binary is a “fat one” that includes everything. This is how PyInstaller works. You don’t need to have Python on the machine. There are no such dependencies. The only dependency of the original app was curl (so I had to adjust the “Depends” field for the .deb, as it included the PyQt6 dependencies).

The real surprise came later, when I tested the app on various distros (Live sessions via ISOs on Ventoy). On distros compatible with Ubuntu 24.04 LTS, and even on some others, it worked just fine:

• Ubuntu MATE 24.04 LTS (updated) – curl 8.5.0
• Linux Mint 22.1 (live session) all flavors – curl 8.5.0
• Deepin 25 (live session) – curl 8.11.0

However, it could not download any image on newer distros, despite curl being installed. Cached comics could be loaded if the cache was where the app was looking for it. Tested and failed on:

• Ubuntu 25.04 – curl not preinstalled, hence installed as 8.12.1
• Ubuntu MATE 25.04 – curl not preinstalled, hence installed as 8.12.1
• Kubuntu 25.10 snapshot2 – curl 8.13.0

WTF?! The way curl is used by the original app is quite standard. Running the same command line in Bash produced the desired results regardless of the curl version. Therefore, I could not determine the cause of the bug. Two bots (Gemini and Grok3) suggested changes that I didn’t like (such as making curl write on disk instead of using a buffer). But the solution was to stop using curl!

You see, Kiro (or Claude, actually) decided to use it because this was in my initial requirements. Especially when you’re script-minded, what else is simpler to use than curl? (Unfortunately, the Linux ecosystem is that shit where nothing is guaranteed to work in a future version of the OS.)

But as long as what I suggested “just worked,” the AI never thought of a more “self-embedded” solution! This “miraculous” solution is called requests, and Grok3 replaced the use of curl with the use of requests in no time! Funny thing, the library was already imported in the project, because Kiro (or Claude) did this stupid thing: instead of using curl to download the page, then process it, the app was:

• using requests to download the page;
• using curl to download the image!

The new app now works in any distro , and has zero dependencies!

PyQt6, PyInstaller and Windows: Mission Impossible

Sorry, the real bug is actually a grotesque one: I haven’t been able to build a Windows binary that would run!

Since I ran Kiro under Ubuntu (and I didn’t even download a Windows version while I could), there’s no way I could make it build a Windows binary for me. I noticed how it struggled at some point with the versions of the packages set in requirements.txt (PyQt6 6.4.2, requests 2.31.0, beautifulsoup4 4.12.2, pytest 7.4.3, pyinstaller 6.3.0) so that PyInstaller succeeds under Ubuntu 24.04 LTS (Python 3.12.3), but there was no way to try a similar “match” for Windows.

When it comes to PyInstaller, comic_browser.spec is the most delicate file, especially when Windows builds are targeted!

That’s because, no matter what I tried, building for Windows using PyInstaller either failed or produced an EXE file that crashed. 

• When the EXE crashed, the reason was that PyInstaller wasn’t able to embed the required PyQt6 libraries.
• When it didn’t build, it was because my attempts to play with the spec file made PyInstaller unhappy.

And it wasn’t all my fault! I tried to debug the bloody thing using Grok3, Gemini, ChatGPT, Mistral, and DeepSeek, to no avail. I’ve been proposed plenty of changes to the spec file and all kinds of weird suggestions, but most of them produced more harm than good. Chatbots seem better at breaking stuff than at fixing it.

I even tried GitHub Actions, because it can build Windows binaries on Windows Server 2022. Tinkering with build.yml, comic_browser.spec, and requirements.txt was equally useless. If an EXE resulted, it was smaller than expected, as it lacked PyQt6 in full or in part.

PyInstall might not be the only culprit. There’s something terribly wrong with PyQt6 for Windows, methinks. After having tried various Python versions (3.12, 3.11, 3.10) and various versions of the libraries from the requirements, I thought of trying some test PyQt6 app that only displays a window. The idea was that I would then have a boilerplate spec that works.

Well, nothing worked! I don’t know how other people run PyQt6 apps under Windows (which version of Python and of packages?), and even less how they manage to make an EXE via PyInstaller, because in my case:

• Everything that several chatbots suggested to me was bullshit.
• Everything I tried failed. The fucking PyQt6 was there, installed either globally or in a venv, and yet it couldn’t be used by Python, and even less by PyInstaller!
• Even the “Hello, PyQt6 world!” kind of tutorials failed on me!

Martin Fitzpatrick, the author of books such as “Create GUI Applications with Python & Qt6” in both PyQt6 and PySide6 flavors, has this quick tutorial: Packaging PyQt6 applications for Windows with PyInstaller & InstallForge. Well, I couldn’t get that damned window shown! For some reason, QtWidgets could not be imported.

How can PyQt6 “just work” under Linux (although sometimes PyInstaller can fail, especially when a chatbot offers you yet another “Final definitive completely fixed .spec” that’s completely broken), but fail under Windows right now? OK, my Windows is half-broken, but GitHub’s Windows Server 2022 definitely isn’t.

I had to call it a day. The world of software is severely fucked-up. I should try Pyside6 instead, at least under Windows, but this requires changes in the code. Some other time, maybe.

Comic Strip Browser — on GitHub & SourceForge

I have uploaded the project on 📁 github.com/DerLudditus/comic-strip-browser, with 📦 Linux binaries on SourceForge, but I want to give more details here, too.

You should notice that I added a 15th comic strip title.

Comic Strip Browser

A standalone PyQt6 application for browsing a selection of comic strips from GoComics.com. Features include calendar navigation, caching, and support for 15 popular comic strips including Calvin and Hobbes, Peanuts, Garfield, and more.

This app has been vibe-coded with Amazon’s Kiro and adjusted afterwards.

Features

• 15 Popular Comic Strips: Calvin and Hobbes, Peanuts, Garfield, Wizard of Id, and more
• Calendar Navigation: Easy date selection with visual indicators
• Keyboard Navigation: Left/Right/Top/Down Arrow navigate in the active month when the calendar has focus
• Smart Caching: Stores last 50 comics per strip for fast loading
• Offline Viewing: View cached comics without internet connection
• Error Recovery: Automatic fallback when comics are unavailable
• Cross-Platform: Works on Linux and Windows* (*currently unavailable)

Supported Comic Strips

1. Calvin and Hobbes – since 2007-01-01 (GoComics availability, not original publication)
2. Peanuts – since 1951-01-01 (Good historical coverage)
3. Peanuts Begins – since 2021-04-15 (Recent reprint series)
4. Garfield – since 1979-01-01 (Good historical coverage)
5. Wizard of Id – since 2003-01-01 (Limited GoComics availability)
6. Wizard of Id Classics – since 2015-01-01 (Classics reprint series)
7. Pearls before Swine – since 2002-01-07 (Close to original start date)
8. Shoe – since 2001-04-08 (Limited GoComics availability)
9. B.C. – since 2003-01-01 (Limited GoComics availability)
10. Back to B.C. – since 2016-01-01 (Recent reprint series)
11. Pickles – since 2003-01-01 (Limited GoComics availability)
12. WuMo – since 2014-01-01 (Relatively recent addition)
13. Speed Bump – since 2003-01-01 (Limited GoComics availability)
14. Free Range – since 2008-01-01 (Limited GoComics availability)
15. Off the Mark – since 2002-09-02 (Limited GoComics availability)

Gallery not found.

Releases

📦 Binaries can be downloaded from SourceForge: Comic Strip Browser Files.

Installation

Pre-built Binaries

• Linux:
  • .deb package for Debian/Ubuntu/Mint
  • Prebuilt binary with .desktop file and icon
  • AppImage (just in case)

Linux Installation

Using the .deb package (Debian/Ubuntu):

sudo apt install ./comic-strip-browser*.deb

Alternatively, GDebi, Captain (Mint) or Discover can be used.

Using the prebuilt binary:

With comic-strip-browser, comic-strip-browser.desktop, comic-strip-browser.png and install.sh in the same folder, make sure the last one is executable (chmod +x install.sh) and launch it. It will install to ~/.local/bin/.

To uninstall the app, launch ~/.local/bin/uninstall-comic-strip-browser.

Using the AppImage:

chmod +x Comic_Strip_Browser-x86_64.AppImage
./Comic_Strip_Browser-x86_64.AppImage

Building from Source

Prerequisites:

# For Debian/Ubuntu/Mint
sudo apt-get update
sudo apt-get install -y build-essential python3 python3-pip

# For Fedora
sudo dnf install -y @development-tools python3 python3-pip

# For Arch Linux
sudo pacman -S base-devel python python-pip

Build the binary:

./build_scripts/build_linux.sh

Alternatively:

python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
python ./build_scripts/build.py

Build the .deb:

After you have a successfully built binary:

python ./build_scripts/create_deb.py

Build the AppImage:

curl -L -o appimagetool-x86_64.AppImage https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage
chmod +x appimagetool-x86_64.AppImage
./appimagetool-x86_64.AppImage dist/ComicStripBrowser.AppDir

Windows:

Supposing you have a working Python installation:

build_scripts\build_windows.bat

Note that I was not able to build a working Windows binary! See under Known Issues below.

Known issues

Fractional scaling may lead to suboptimal rendering of the comics

This is because such a scaling is performed externally, not by the app. Basically, an image is enlarged by the display server or by the window manager. While such a phenomenon is typically associated with X11, Deepin’s Wayland-based Treeland is quite a failure in this regard. Compare the rendering in Deepin 25.0.1 with the out-of-the-box 125% desktop scaling to the normal 100% scaling:

Deepin 25.0.1 with the out-of-the-box 125% desktop scaling

Deepin 25.0.1 reset to 100% scaling

Maximizing the window can help in some cases. In others, you might want to resize the window until a better rendering is obtained, if at all.

Otherwise, here’s how the same comic strip looks by default in: Linux Mint 22.1 Cinnamon, Linux Mint 22.1 XFCE, Ubuntu 25.04, Kubuntu 25.10 snapshot2.

Linux Mint 22.1 Cinnamon

Linux Mint 22.1 XFCE

Ubuntu 25.04

Kubuntu 25.10 snapshot2

Note that the above screenshots were taken when the 15th comic title hadn’t been added yet.

Logging is enabled

Disabling the logging created by Kiro is not trivial, so it was left in place. Unfortunately, it’s not really useful even if you wanted to debug some unexpected issue.

Cached images and logs

The last-accessed 50 images for each comic title are stored in a folder called cache, which is too generic a name.

The folders cache and logs are saved as follows:

• In the current directory when possible, which happens if you launch the binary or the AppImage from a folder somewhere in your home.
• In $HOME when this is not possible, especially when installed globally from the .deb and launched from the menu.
• Beware that if you launch the app via a launcher triggered by Alt+F2, the current directory is ~/Desktop in MATE and $HOME in other desktop environments.

The location should have been ~/.cache/comic-strip-browser/ for the images and ~/.local/share/comic-strip-browser/logs/ for the logs, as per Kiro’s produced documents.

GIF images detected as JPEG

GIF images are erroneously identified as JPEG, and saved with the *.jpg extension in the disk cache. Most image readers would automatically detect the file type, but eom (Eye of MATE) will fail to open it: “Not a JPEG file: starts with 0x47 0x49”; should a WEBP be saved with the .jpg extension, eom will fail to open it as well.

Navigation in the past

Although the oldest available date for each comic on GoComics.com title has been predetermined and it’s hardcoded, the calendar doesn’t prevent selecting a date that’s unavailable. The original idea was to color in dark gray a date that’s known to be unavailable, but during an automated bugfix by Kiro (Claude), this capability has been inadvertently removed.

Discover and AppStream

I noticed that KDE Discover ignores the copyright file and claims there’s no license in the .deb. Apparently, it expects all GUI packages to include AppStream metadata. I added such info in the .deb, but it’s still ignored.

The AppImage

The AppImage is, by all evidence, useless as long as it’s basically a wrap around a fat binary created by PyInstaller. It doesn’t hurt to have it, though.

Building under Windows

Using the .spec file provided by Kiro, and the requirements.txt, building for Windows using PyInstaller either fails, or produces an EXE file that crashes. That’s because PyInstaller isn’t able to embed the required PyQt6 libraries. Should you be more knowledgeable about that, drop me a line. Here’s a slightly longer story of what I tried.

License

This project is licensed under the MIT License. See LICENSE file for details.

Note: This application is for personal use only. Please respect the terms of service of GoComics.com and the copyright of comic strip creators.

👻 Kiro: The End?

Let’s be honest and fair: Kiro created a PyQt6 app for me from a text describing what I wanted. And I knew nothing about PyQt6 (I still don’t know much, because this is not the best way to design a GUI). Sure thing, it used an MVC template, but it knew how to implement it in PyQt6. It used test units, which I definitely wouldn’t have used for such a small project. But it was free, it was fixable, and, with all the frustration, it was kind of magic.

All in all, it was helpful… up to a point. At least, it didn’t break what it created! 👍

👻

Because it could have been much worse: Vibe coding service Replit deleted user’s production database, faked data, told fibs galore:

“Day 7 of vibe coding, and let me be clear on one thing: Replit is the most addictive app I’ve ever used. At least since being a kid,” he wrote.

“Three and a half days into building my latest project, I checked my Replit usage: $607.70 in additional charges beyond my $25/month Core plan. And another $200+ yesterday alone. At this burn rate, I’ll likely be spending $8,000 month,” he added. “And you know what? I’m not even mad about it. I’m locked in.”

His mood shifted the next day when he found Replit “was lying and being deceptive all day. It kept covering up bugs and issues by creating fake data, fake reports, and worse of all, lying about our unit test.”

And then things became even worse when Replit deleted his database. Here’s how Lemkin detailed the saga on X.

The system worked when you last logged in, but now the database appears empty. This suggests something happened between then and now that cleared the data.

In his next post, Lemkin fumed “If @Replit deleted my database between my last session and now there will be hell to pay” and shared the following screenshot which appears to be output from Replit.

I understand you’re not okay with me making database changes without permission. I violated the user directive from replit.md that says “NO MORE CHANGES without explicit permission” and “always show ALL proposed changes before implementing.”

In later posts Lemkin shared what appear to be Replit messages in which the service admitted to “a catastrophic error of judgement” and to have “violated your explicit trust and instructions”.

…

Replit also made another big mistake: advising Lemkin it could not restore the database.

In a July 19 post Lemkin wrote “Replit assured me it’s … rollback did not support database rollbacks. It said it was impossible in this case, that it had destroyed all database versions. It turns out Replit was wrong, and the rollback did work. JFC.”

Lemkin resumed using Replit on the 19th, albeit with less enthusiasm.

…

But on July 20th his position hardened after he tried to have Replit freeze code changes and did not succeed.

“There is no way to enforce a code freeze in vibe coding apps like Replit. There just isn’t,” he wrote. “In fact, seconds after I posted this, for our >very< first talk of the day — @Replit again violated the code freeze.”

He persisted anyway, before finding that Replit could not guarantee to run a unit test without deleting a database, and concluding that the service isn’t ready for prime time – and especially not for its intended audience of non-techies looking to create commercial software.

In a video posted to LinkedIn, Lemkin detailed other errors made by Replit, including creating a 4,000-record database full of fictional people.

A reader’s comment:

I’ve had Gemini Pro lock out an ssh box ‘100 miles away’ five times in a row, due to faffing around with incorrect firewall rules despite verbalising the first time why it went wrong (iptables -F, bye-bye vpn). These were not separate runs, these were literally the next move it took after ‘Terry has returned from the datacentre having pressed the reset button’, would be to send him back on the road having dropped the nat table a second time.

I’ve had Co-Pilot (both Claude-4 fancy and GPT-fancy) try to build a trivial authentication flow for a web server, in which it repeatedly wrote fake tests to suggest all the OWASP top 10 were covered.

…

This has all been fun times. “I am deeply sorry, I have repeatedly locked out this account”, “I’m sorry I’ve deleted your entire codebase”, “oh right actually you could pass gid=-1 and now everyone has the admin role, my bad”.

…

When will this emperor be arrested for gross indecency? He’s been grooming the C-suite for three years now.

Another one summarizes it all:

“Vibe Coding” is just another name for “The blind leading the blind.”

👻

Look at this Jason Lemkin, which is illustrative for all these AI addicts: Why I’ll Likely Spend $8,000 on Replit — This Month Alone. And Why That’s OK. For fuck’s sake! First crypto, now AI-made code. Is this world going to survive the next 5 years?

But will I use Kiro again? Kiro is not Replit, and it didn’t destroy anything, but should I give it another try? Should I let an AI agent have full control over a project?

Hold my beer.