“Task Failed Successfully”

Posted on by

“Task failed successfully.” It’s a fake* prompt, which inspired a meme, which inspired a widespread descriptive term. It’s a joke, and an absurd joke, but like many absurd jokes it exists and persists because it reflects something real.

The mimetic form created by this joke tells the story of a goal gone so wrong that it went right. A failure that leads to success. As the subreddit dedicated to this form defines it, the situation occurs “when tasks fail in such a way that leads to success.”

The form, the whimsy of it is fun because it is a true representation of one of the absurd joys of life, which defies your struggles, yet rewards your ineptitude, as if to say, “‘A’ for effort — and did you learn something?”

Hopefully, you did. Most (not all) kinds of failure include reward, and there’s no need to retell the well-studied story of victory built on ruins.

I had this kind of experience building a small personal project. It went wrong, in a way that proved to be just what I needed.

 

Screenshot of personal project "horizon initiative"

This screenshot shows the unfinished, but functionally complete, main page of my little app (give little credence to the campy name; the project was never intended to be public-facing).

I built it to 80% completion (yes, that magic number), or maybe more, and then condemned it to the project junkyard. But discarding was the act of victory.

The purpose

Like many tinkerers and coders, I do not appreciate the limitations of most apps available to handle common tasks. There are uncounted apps and programs for (among other purposes) calendars and scheduling, messaging and communication, and project or task management. This last was my target here — a goal management application that fit my needs and no one else’s.

Trello — not the right angle. Jira — too complex for my limited scope. A customized CMS instance — too much to edit. A simple notepad — too easily forgotten. Over and over I iterated the various options, and of course, tried to configure my way out of a fundamental misfit.

That slowly growing frustration of course eventually manifests as the garden bed of a new project.

The goal

My needs were limited but specific: a list of items, seen in minimal format but with details available. These items are not quite tasks, which are completed rapidly, nor are they projects, which include a specific process or defined end. My list items lie somewhere in between, and contain elements of both, perhaps categorized closer to goals.

In specific, I wanted a few key elements:

  • A main page for the user (i.e. me) to see all active list items in their minimal form
  • Detailed views for each item where I can see my notes about them and edit as needed
  • Rankings of these items by how recently they’d been worked

So far, so simple — this is not dissimilar from many existing management apps.

But a few nuances made this a lot harder, because I also needed:

  • To not have to edit the item, or take effortful action with it, for it to count as “worked” or “updated”
  • To be able to track these items ongoing with a limited amount of time investment
  • Simplicity and ease of use of the view and edit, with no clutter

The app

Well, if I wanted to update my tasks without having to click into them, and to keep the list up to date without having to modify views, I was going to have to go custom. I also wanted to have a solution that was easy to manage, without extra content or configuration once set up.

In effect, this created a set of requirements for the app:

  • A CRUD process for a list item
  • The structure for a list item, to include:
    • A name / summary
    • A created date (later dropped)
    • A modified date
    • An expected completion date
    • Tags, for organization
    • Notes
  • A list view with the most recently modified items at top, where each item shows only key fields
  • A detail view for an individual item
  • A simple process by which to update the modified date without having to manually edit the item

The process

Possibilities abound to create a new app. Any tinkerer knows you have to reign yourself in or you’ll get nothing done. So I committed the cardinal sin of choosing the best, most efficient path possible — I used an LLM AI to help build the thing. I had already decided to use Ruby on Rails for the app, as I know it fairly well and it’s also relatively easy to host. So I threw the background of the application’s goal and a few target parameters at the API of ChatGPT (really the playground, but close enough) and chewed through some back and forth until the end result was a nearly fully-fledged app.

It’s absurd, but it’s also real. Many of the complaints against generative AI stem from its inevitable inaccuracies. But practice makes perfect (on the human side anyway, and a bit on the AI side, too), and iterating on the problem, every model quickly exposes the way it best responds to prompts (I guess this is “prompt engineering,” mostly intuition in this case).

As a result it did not take long to go from “explaining” my goal and limitations to iterating on the specifics of the design and drilling into what were effectively user stories for the goals I had in mind, such as exposing a button that would update just the date modified for an item from the list view (I called this the “lift” button in a spontaneous moment of positivity, not unwarranted for an app intended to engender success).

Before long I had a workable app, and visually pleasing, too (at least to me), even after running out of ChatGPT’s context window and having to either re-explain or simply interpret some of the guesswork it had to do on my more recent inputs. An upside of using Rails was that the AI could have the app rely on the framework for a lot of the heavy lifting to complete standard features (this would apply in other frameworks, too; the key point was avoiding the temptation to build from scratch, even with the use of libraries for features like date management, etc).

And so “I,” or “we,” built a functional, usable goal-management app. It includes full auth (simple, but secure), an API, etc, all the standard features you’d expect of a completed personal project.

The exciting part (to me anyway) is I was able to spin this up in ~4 hours, including tweaking the code manually to compensate for some nuances that the AI did miss. As a perennial “optimizer” I am guaranteed to have a fight with myself at every juncture to stick to the mantra of perfect being the enemy of very good, and accomplish something lovely rather than fail to accomplish something perfect. Using the AI made this possible, by taking the common, long, frustrating components of development almost entirely out of my hands and letting the AI build them — even sometimes choose them, in a limited way, under direction — and leaving the orchestrating and the fine-tuning to me. Most of the rest of the time not spent working with the AI was spent on small customizations — adjusting CSS or finding images to use, things like that.

The result

So there it was — it ran, it worked, it did what I wanted, and it looked and felt how I wanted, and it was basically done! My project was ready to go. There were some additional tweaks I wanted to make — having the lift button move the item to the top of the list automatically, for instance. Small quality of life adjustments. But it was time to start thinking about hosting.

Originally, I was going to host this on Render. They have a really great entry tier and simple deployment process — great for low-key personal projects like this one.

Of course, in the end, I didn’t deploy it at all. I realized, just a bit too late, as I was testing the app, that I wasn’t really going to use it. I have a whole bunch of small little apps and processes in my life and I didn’t want one more, even for this — and that’s not even including all the larger task-oriented items I use for work. I just wasn’t going to stick with this one, and my little text document where I keep most of my project / goal notes can do for now. If I ever shift my processes, I can think about it again then.

So, this exciting, functional, nearly complete personal project has landed on the big heap of discarded projects that sits on various hard drives. I don’t mind. Far from it! It was only a small amount of time investment, and I gained two important things:

1) Proof of the concept. ChatGPT and a handful of other free tools let me build out a real, usable, reasonably secure and robust application in fractional time that was . In the process, I refined my understanding of so-called “prompt engineering.”

2) A usable framework — as noted this is pretty much a complete, if minimal, application. More importantly, it’s something that I can adjust quickly, and deploy quickly, any time. As a reference point, it will be a useful item in the library (as long as I remember it’s there!) I can reuse it in whole or in part, pick out snippets of code, turn it into something else, or decide to pick up where I left off. The code is pretty stable and RoR doesn’t change all that fast at its core, so it should be a fairly quick pickup even years from now. It’s hard to look at that as a waste of time! I look at it as a victory.

 

*  *  *

 

So there’s my “task failed successfully.” A whole project, completed, and then discarded because I realized too late I didn’t need it. But I’m so much the better off for having done it. Despite dabbling plenty with AI, I’d always wondered if I really would ever be able to use it in a practical use case for anything beyond a minimal bit of text or code. Now I know! And this experience provided the springboard to be able to take a similar tack for other projects, other goals. I’ve learned key insights about building with AI, and have a nice shiny personal project to look back on and reuse, as well.

As futile endeavors go, this one rocked! 5/5 stars, would recommend.

 

Here’s a very short demo of the working app, as an end item:

 

* “Fake” in that it isn’t caused by any viable circumstances in the Windows XP UX, real in that it was probably a coded prompt, not an edited screenshot.