Five days ago all I had was a handful of great ideas, half a plan, and zero functioning demos. Now I’m heading home having accidentally discovered something that just might reshape the way I think about AI orchestration entirely

Blurry Lights, Ax and the Hatchetmen (a killer listen)

But how did we get here?

Well, before we begin, it’s time for some disclaimers.
First: This blog post is my first attempt at a curated experience in writing - something I’ve been ideating for a while. I’ve embedded music throughout this piece that reflects my mood at each moment. Listening isn’t required, but if you want to feel this story, put on headphones and let the music color in the picture laid out by the words.
I offer you total immersion, should you choose to accept it.
Second: If you’re reading this because you want the prompts used in the pre-con at PASS Summit: I will touch on those in this article, but I’ll have a much better prepared article coming out soon specifically about those prompts, as well as some never-before-seen ones I skipped in the presentation. Stick around for that, I’ve been told the competitive edge is worth the lackluster writing…

Noon of the First Day

Friday (T: -02:20:00)
Shrike Media HQ,
Blackstone, VA

We kicked off the day with an absolutely excellent show. (Engineer of Data on Substack, live every Friday at noon!) No technical failures, wonderful audience. Great interaction from legends Chris Wagner, Jeff Taylor, and Mark Tabladillo. We briefly recapped what we were planning to present on at PASS, hung out with the audience, and got the framework API we’d been building live on the show to survive a full demo! All things considered, a massive success.

Friday (T: -02:10:25)
Hilton Garden Inn,
RDU Airport, NC

It is 8:30pm, we’re in the hotel at the airport, we have to be out of the hotel at 4:30am, and my demos have finished being conceptualized and have wandered into the active development stage. You see, since I was such a last minute addition to the pre-con, I had very little time to prepare. All of my demos worked conceptually, but no plan ever survives first contact with the enemy. No juice left tonight though, time to sleep.

Dawn of the Second Day

Saturday (T: -01:21:35)
Delta Flight DAL354,
Somewhere Over Montana

The plane is landing in one hour, and I am on the edge of my seat. Spine aching, teeth grinding, the drone of the fuel pumps drowning out every other bar of “Free Woo“ by 42 Dugg. The reality of the situation is setting in: I am on the other side of the country, just shy of two days from presenting, and for the last three hours my first demo has been refusing to work.
I had been waiting for Claude Code to finish working on my latest request while I continued to feed my Trimps addiction. Hearing the ping from Claude I paused the game and tabbed back into my browser. Claude has finished my request and is notifying me the pipeline is ready for a deployment test. Same as before, I’m not impressed. However, this time it was different. I click over into Fabric expecting to see my favorite “corrupted metadata“ error preventing me from merging the pipeline into the workspace through source control.
But it wasn’t there. Instead, I had a red circle with a “1“ inside it sitting right beside the “Source Control“ button. I can remember thinking “huh, is that what it looks like when it works?“ As it turns out, the answer was yes. The pipeline had been formatted correctly and I had discovered a piece of information that would be pivotal to my presentation.
In that moment I realized the mistake causing the generated pipelines to be “corrupted“. Fabric uses GUIDs in the LogicalID and WorkspaceID fields. Earlier I had discovered Fabric expects the WorkspaceID to be a zeroed out GUID. But I was still having issues with the LogicalID GUID.
I thought to myself “Claude could probably generate a GUID and drop it into the field…” I decided it was worth a try. It turned out that Fabric doesn’t care who assigns the GUID for the LogicalID, only that one has been assigned. The pipeline was now in the Fabric workspace, all I had to do was execute it. It worked on the first try.
This is huge. I had managed to take the JSON that constitutes a pipeline, break it down into Design Pattern and Pipeline Metadata files, then reconstitute a new pipeline from those files; a process I call “Dehydration“ and “Re-hydration“ respectively. All I had to do was guarantee the LogicalID was assigned a GUID, and the WorkspaceID was assigned an empty, non-null, GUID.
The plane was beginning to angle down for final approach, and Youtube auto-play just ticked over to “Sprinter” by Dave & Central Cee. As the seat belt lights came on I closed the lid on the laptop feeling like I might just have a shot at making all of this work out. As I watched the mountain tops disappear above the clouds, and the mountain bottoms appear below them, two feelings did battle in my head. On one hand, the music matched my mood: the Marlon Brando vibe married nicely with the feeling of arriving at a place I was invited to because someone thought my work was interesting enough to be taught. On the other hand: I had only just figured out the first of four parts needed to convey the importance of what I was there to teach. It was anxiety inducing and invigorating at the same time. Truly a vertigo inducing series of emotion. Thankfully, I have nearly two entire days to make the next three work!

Saturday (T: -01:19:39)
The Tree Hive,
Near Seattle, WA

After deplaning we immediately hit the road to visit a good family friend, Donald Farmer!

The entire house, the whole property for that matter, felt like one big, cohesive, art exhibit. It was truly beautiful. Massive thank you to the Farmers for letting us stop by and hang out!

Saturday (T: -01:15:53)
Hampton by Hilton,
Seattle, WA

Remember when I said I had “nearly two entire days“ to make the next three demos work? As we got back to the hotel the realization, that I really only had two nights, hit me like a sack of bricks. Regardless, we were on a roll Saturday night. We managed to get one (1) entire demo to work after 3 hours of collectively banging our heads against brick wall.

Admittedly, as much as I’m making it sound like a bummer, this was truly a massive success. Dehydration and re-hydration were the fruits of yesterday’s labor. Today I successfully re-hydrated a pipeline from a Design Pattern file with user supplied pipeline metadata, instead of metadata stripped out of a preexisting pipeline! As far as I know, this was the first Fabric pipeline created by AI without metadata originating from the Fabric environment. That pipeline executing successfully was the key to the trove of near endless possibilities with AI orchestration in Fabric, and we knew it. We now had the power to spin up a pipeline based on any design pattern we could feed into the machine AND we could fully customize the pipeline metadata WITHOUT ever touching Fabric. That little green circle with the white check mark on the pipeline activity output was like pulling the pin on the exhaustion grenade. I finalized my notes, left myself some reminders of things I’d learned, and looked at the clock. The numbers were alarmingly near to rolling over to tomorrow, and that meant it was bed time.

Two demos down, two to go.

Noon of the Third Day

Sunday (T: -00:20:00)
Hyatt at Olive 8,
Seattle, WA

It’s crunch time, and I can feel it. I’ve got exactly twenty hours until I have to deliver this pre-con and, while I know for certain my last two demos will work conceptually, I haven’t proven it.

It was time to prove it.

I knew my third demo would be easy, all I had to do was run the second demo three times in parallel with some minor modifications to the Pipeline Metadata that would be supplied by the user. What ended up complicating this demo comes down to the inherent solution instability that comes with AI. You see: AI is, at its best, controlled gambling. The input has a great deal of impact on the output, but every step between your prompt and the desired output introduces noise. The more specific and detailed your instructions, the smaller the pool of possible outputs, and the less likely you are to get something unusable. You can never guarantee the outcome. You can only tilt the odds in your favor.
To simplify:
Higher quality input shrinks the pool of total outcomes.
Longer procedures introduce more opportunities for the AI to get confused.
Each time the AI gets confused it has a chance to make a decision that’s almost right.
Each almost right answer deflects further from the desired output.

This means, due to the nature of currently available AI, you can never guarantee an outcome, only reduce the likelihood of a wrong answer being generated.
This poses a non-insignificant issue for giving demos using AI. After all, you want your demos to succeed. Otherwise people have spent all that time listening to you talk just to learn how to fail, and while that can be useful, it was absolutely not the goal I was aiming for.

So how do we solve this issue?
Good news: There’s a very easy solution to this problem!
Bad news: It only applies in a very limited number of use-cases…
Great news: This is one of those use-cases!

The solution here is, of course, telling the AI the exact end goal you’re looking for in the prompt. It seems silly to build this much tension over such a simple solution, and you’d be forgiven for feeling that way. Truthfully it’s not the solution that’s complex, it rarely is, but rather the situation it applies to, and the method of execution, are the complex parts. In this situation I happen to know exactly the outcome I’m looking for down to the very last variable in the pipeline metadata. All I had to do was some R&D

into how best to communicate that desired outcome to the AI in a way that could be reliably interpreted to mean the same thing every time it was ran. This task ended up being slightly annoying, but overall pretty simple.

Three down, one to go.

Sunday (T: -00:12:35)
Hyatt at Olive 8,
Seattle, WA

After an amazing dinner with dad we hit the room running. One last demo to translate from the flesh computer in my head to the silicon-based one at my finger tips.

So far I’ve dehydrated and re-hydrated a pipeline, re-hydrated from user supplied pipeline metadata, and re-hydrated with user supplied metadata three times in parallel. Now it’s time to build a Controller Pipeline.

Ultimately a Controller Pipeline is just a pipeline with one, or more, Invoke Pipeline Activities inside it. But why? Why go through the trouble if you can just execute the pipelines yourself? Why not throw all activities in the same pipeline?
It all comes down to automation efficiency. Doing one massive task all in one go can be very slow. Break it up into smaller, simpler, tasks and run them in parallel and you’ve got yourself a pipeline that screams.

But I’ve already built pipelines with Claude, that wouldn’t be new, just slightly different. I needed more magic.

Here’s my approach: I figured if I’d already filled Claude’s GitHub repo with Design Pattern and Pipeline Metadata files from existing pipelines, I just might be able to get Claude to reference that knowledge as a whole rather than individual parts. First I created a pipeline with an invoke pipeline activity in it in Fabric. Then I asked Claude to dehydrate it and store the analyzed data in the GitHub. Finally, I set about engineering my prompt.
The magic I wanted to bring to the forefront in this demo was Claude’s ability to turn natural language into executable pipelines. I decided to give Claude the bare minimum information it needed to complete the task.
I’ll add here: I do NOT recommend this as standard practice. I use it here to demonstrate Claude’s input flexibility. However, I still strongly recommend a well engineered, clear and concise, prompt for normal use.
I pointed Claude at the dehydrated sample controller pipeline from earlier then described the desired controller pipeline architecture, simply a pipeline with three Invoke Pipeline activities in it, pointing at the three copy pipelines it created in the parallel pipeline creation demo.
I fully expected to be up late into the next morning debugging this prompt. I hit Enter, hit play on “Dark Thoughts“ by Lil Tecca, and got up to grab some water.

Monday (T: -00:07:28)
Hyatt at Olive 8,
Seattle, WA

I sat down, having acquired my aforementioned water, and look up to a very interesting sight. It worked. Claude had not only finished the task early, but also claimed it was certain the solution was accurate. Claude claiming a solution will work isn’t out of the ordinary. If you were at the pre-con you’d have heard dad and I spam our favorite Claude phrase “You’re absolutely right“. A phrase indicative of AI’s tendency to be incredibly sure of itself. But for Claude to claim certainty that a given solution would work is a lot rarer for me. I’ve put in place some engineered system prompts for Claude that thoroughly discourage it from thinking its solution is correct without testing. These system prompts also instruct Claude to be reserved, concise, and to tone down the excitement. This isn’t because I’m some killjoy, getting a masochistic enjoyment from being happier than my AI. Rather, it’s a token saving method; it’s also of minor importance to how Durandal (my other project) stores memories.

I was skeptical out of the gate. I figured if it had worked it will have only half-worked and there’d be some silly minor fixes I’d have to make that’d end up keeping me from sleeping the, now morning, of the con.
I tabbed back into Fabric and sure enough source control had no issue merging the new pipeline into the workspace. I hit execute and waited, and waited, and waited… This is due to what I later found out was a normal function of Fabric Invoke Pipeline activities taking forever to execute for a reason that still isn’t apparent to me.
Lo and behold, the pipeline executed without errors. It worked!

What I didn’t know, but soon found out, was that I had accidentally stumbled into what would become the basis of my current research focus. I had (re-)discovered Claude could still build new skills if I fed it enough data and gave it a place to store its working set of information.
This may sound a bit slow of me, and if you’re thinking that, we’re on the same page. You have to understand: my knowledge of AI and its inner workings are relatively siloed around the tasks and situations I use it for. In this case: I already knew Claude could use information it gathered to build better answers, that’s what I wrote Durandal for after all, but I hadn’t thought to use memory as storage for information that could be later used to learn new things. Why is this exciting? I highly doubt, though I cannot prove, that Claude’s extensive knowledge base covered specifically how to create a pipeline of any kind in Fabric, let alone a Controller Pipeline. Circumstantial evidence supports this with the early struggles in this process being getting Claude to understand what a pipeline even is and how to build one without catastrophically failing the source control merge compatibility scan.
The fact that Claude created a Controller Pipeline with almost zero hassle based entirely on natural language in the user prompt implies it filled in the gaps by referencing the design patterns and pipeline metadata it had collected in the GitHub. It wasn’t just following instructions, it was synthesizing an entirely new solution based on prior knowledge.

That’s not retrieval. That’s something akin to learning.

This was good. The demos all worked and were ready to be presented at the pre-con. Finally, at 1:40am, I allowed myself to go to sleep.

As I laid in bed the realization I had improvised my way into a real, usable, industry-standard-defining solution, hit me. I was happy the demos worked. But more than that, I had proven to myself that I could do it. I am my harshest critic by design and intent. I’m notoriously strong willed (stubborn) and I had finally satisfied myself with the knowledge I had made the problem quit before I did.

Dawn of the Final Day

Monday (T: -00:02:00)
Hyatt at Olive 8,
Seattle, WA

That was a rough five hours and 17 minutes of sleep. But, with a bacon, egg, and cheese everything bagel and two cups of the blackest coffee Starbucks could offer, I was ready to conquer this pre-con.

Monday (T: -00:00:00)
The Summit Building,
Seattle, WA

It’s go time baby.

We’re immediately hit with the worst failure possible. Dad is trying to connect to his VM, but the PASS Speaker Network is a metered connection. The VM doesn’t appreciate this at all.

This is the exact point where the horror show begins.
I watched on, frozen in fear, filled with the acute agony of watching someone you love hit a brick wall at a time where it cannot be afforded. I saw dad speed run all stages of grief in a handful of seconds.
First, denial: “This should be working…“ Followed by anger: a single, sharp inhale. A slight tremor in the hands. Then bargaining: “If you’ll bear with me just a moment.“ Followed closely by depression: “I’m so sorry y’all, I’ve never had a VM fail this catastrophically.“ And finally, acceptance: which, for Dad, has no external visual indicators. Internally though, something akin to a mental rolling up of sleeves was occurring.
It felt like all of the air had been sucked out of the room. For a brief moment the loudest thing in there was my tinnitus pinging and chirping in my ears.
I have grown up my entire life with my dad being one of the smartest, most capable people I know. If he’s having trouble this early on, what does that mean for me?
Dad was on top of it. Throughout my childhood Dad would repeat a phrase to me every time I ran into a problem I couldn’t solve: “Don’t let the problem be smarter than you.“ In this moment, after taking a massive loss in front of people who he knew looked up to him, he made a decision.

It was as if the cork was popped on the vacuum filled bottle that was the lecture hall. The air rushed back in, the color returned to his shock paled face, and a small smile appeared.
He immediately pivoted to rebuilding the entire demo environment live, in front of a room full of industry professionals, while I sat on the sidelines trying to kick start my heart and lungs. With the crowd on the edge of their seats, he managed to not only deliver all of his material, but also run almost every demo. All while delivering what was possibly the most comprehensive and intense example of not folding under insane pressure I’ve ever seen. This is the differentiating factor that pushes someone from thinking their dad is smart to being proud and honored to be recognized by their last name.

Monday (T: +00:05:21)
The Summit Building,
Seattle, WA

Be not afraid, the horror show doesn’t end any time soon. I stand up and move my laptop over to the podium. Aside from the communication failures common to first time presenters, my presentation went really well and the demos were holding. Right up until they weren’t.

I started my section by going over Prompt Engineering, the intricacies, the delicacies, you know the spiel. I could feel myself fumbling around a bit in my head, trying to orient my thoughts as they were on their way out. The meandering nature my speech took on was a reflection of my mental state, and people were noticing. Luckily, I was blessed with one of the nicest audiences I’ve ever seen. I saw maybe one person who seemed annoyed and frustrated. Every one of the 58 other individuals in that room wore looks of empathetic shared embarrassment. Not in a rude way though, in the way you look at your little brother or sister, who’s fumbling a presentation at school that you know they worked very hard on, because they didn’t anticipate the anxiety of presenting in front of all their classmates. Noticing and identifying that look on so many faces gave me the brief moment of clarity I needed to think: “Okay, they don’t all think I’m a failure. They’re not looking for an excuse to leave, they want to see me succeed.“

I held up a finger, paused for a moment, wrung my hands behind the podium, took a deep breath, and centered myself. If you must know: I was picturing the scene from the first Iron Man where Tony Stark is about to present the new Jericho missile.
I apologized for my fumbling, wrapped up and recapped my talking points about Prompt Engineering, and announced it was time for the 3:15 break.

When we came back, it was time for some demos. The first three went off without a hitch. I was able to demonstrate Claude doing what Claude does best, and the audience was almost as stunned as I was when everything executed successfully with minimal hassle. As I moved on into my fourth and final demo that old freak Murphy showed up to impose his law.

Some changes made in Fabric completely altered the way something interacts with the Invoke Pipeline activity. It was not a good time for something like this. I was just starting to feel the confidence of cruising through three demos with no issues.
I was getting a “Corrupted Metadata” error again, despite running this exact prompt multiple times less than 15 hours ago.
The audience was riding along a carefully curated roller coaster of emotion I had built over the last three demos. Now it’s dead on the tracks 20ft from the peak of the biggest drop.
I could hear myself think: “This happened to Dad, he recovered. This is savable.”
I pivoted, opened the JSON that made up the pipeline, and sure enough, the formatting was fine. The LogicalID and WorkspaceID GUIDs had been assigned as expected, and Fabric was still throwing an error. Through carefully parsing the error I discovered the issue. Somehow, in the midst of processing my request, Claude had forgotten the GUID needed to be unique, and had assigned the one from the sample controller pipeline I had provided. I resolved this with a correctional prompt and took questions while Claude worked. When I returned to the podium I was able to merge the generated controller pipeline into the workspace. This sudden release after several minutes of agonizing anticipation earned the first applause.

Home free… right?

At the time of writing I still do not understand what caused Invoke Pipeline activities to stop working so suddenly. It has been, and will likely remain, a mystery. The pipeline passed validation, Claude could find no issue with the way it was written, and nobody in the room could think of a reason it wouldn’t work. I didn’t know what to do, and I could feel the already slipping gears in my head begin to grind violently.
It was at this moment I heard: “Hey, they just released the platform today, maybe it’s just a bug?“ An audience member, who had been asking me the hardest questions back to back all evening, had spoken up. The contemplative silence that followed gave me the brief interlude I needed to realize 100% of the pressure I was feeling directed at me was coming from me. I collected myself again and did a temperature check on the audience to see how we felt about pivoting to the backup workspace. We agreed and accepted it for the experimental service we knew it to be and moved on.
I pivoted to my backup environment, praying with everything I had that the backup workspace hadn’t been hit by whatever had broken the demo one.

It was not.

I clicked execute and the pipeline fired off. I offered to answer questions in the time it would take to run, but we were all so engulfed in seeing this pipeline run we mostly waited out the 79 seconds it took to execute.

When the page refreshed the pipeline had succeeded.

A noise like large bore straight six engine slamming into first and dumping the clutch reverberated around the inside of my skull. I couldn’t contain myself, both my fists came up and I let out a “YES!!“ and a sigh of relief. This small miracle, and my handling of the error after the previous sub-optimal attempts, earned the second applause of the night; and the first one I felt was truly earned.

The audience was incredibly forgiving - more than I could ever ask for. I managed to present all of the material I had and almost all of my demos. Though the information contained in the demos was relatively complex, most people seemed to extract as much value from it as I was trying to convey.

I had done it. It was over.

We returned to the room after some incredible pizza dinner with the other parent/child presenter pair. Dad gave me a hug, told me he was proud and that I did a great job, and promptly went to bed. I, being not totally immune to my Gen Z nature, made a couple posts on Instagram and passed out.

Looking back, I’m struck by how much of this felt like improvisation and how that improvisation, somehow, didn’t result in a massive failure. The demos worked. But more than that, I walked away with a research focus I hadn’t expected to find, and the satisfaction that comes from handling extreme pressure without folding.
PASS Data Community Summit 2025 was an experience I hope I never forget, and I can only hope next year will be even better.

Pack it Up

Thank You

This is just the beginning of what I’m hoping will become something much bigger. Thank you again, dear reader, for reading this article this far. Thank you for coming along on this ride. Thank you for supporting me and my cause. Thank you for providing me a platform to share what I’ve learned and engage with you.

You are the reason any of this was possible, and for that, I can never thank you enough.

Paying Bills

There are still many, many stories to tell from this trip, and I may one day tell them, but for now it’s time to begin work on making the pre-con notes and prompts available to everyone.

Starting now I’m launching an effort to share everything I know, and subsequently learn, about AI, prompt engineering, AI integration, security, governance, and more! I plan to have a micro-article out for each prompt I used in the pre-con to help bring some clarity to what can be a confounding subject.

In the event you want to keep up with me, you can subscribe, for FREE, here:

Additionally: If you like what I’m doing and feel compelled to financially support this endeavor, I have recently enabled paid subscriptions. Please do not donate if you are unable to. My personal policy is to never charge money for something that was once free without first altering it to add significant value. Donating is strictly optional and NOT expected.

Finally: If you like this post and want to share it, below is a convenient button!

Share

Thank you! I hope to see you again soon!

For those of you returning to this newsletter: Welcome back! I’m so glad you’re sticking around to follow the development of this product!

For those of you new to this newsletter: Welcome! I’m glad to have you on board for this ride and I hope you decide to stick with it! I’ve been totally blown away by the insane support coming from the community on this effort so far. For those of you following along at home we’re up to 539 installs in five days!

Thank you all again for the immense support up front on this project. I thought I’d be lucky to see 30 downloads at the end of a month or two. I cannot believe the outpouring of support and feedback I’ve seen in just the first five days! Stick around for the ride, if you feel so inclined, it’ll only get better from here.

As I continue to strive for better support and functionality for Durandal, I will also strive to write better newsletters. Here’s how I plan to bring you better newsletter articles in the foreseeable future:

1. I’ll try to include as many pictures as I can to help illustrate the concepts I’m trying to convey. I can (unintentionally) be incredibly obtuse at times, hoping this helps.

2. I’m aiming to bring a minimum of one article to the newsletter each week. I may not always deliver on this if Durandal development takes priority, but I’ll do my best to ensure it stays balanced.

3. I’ll also attempt to include polls somewhere in the article to give you an easier way of letting me know what you’re most interested in having implemented in Durandal.

Durandal has undergone some serious work over the last couple days, and I’m happy to finally be able to share it with you all! Without further adieu:

What’s changed?

Short answer? A lot, and not much at the same time.

v2.1.0 → v2.1.3:

• Fixed a minor memory leak

• Improved error handling - added checks for errors I wasn’t checking for before.

• Stabilized MCP connection - Fixed some faulty behavior that caused MCP launch reliability issues.

• Basic functionality fixes - Helper commands not functioning properly, now operational.

v3.0.0 (Terminal Graphics Release):

Major Update - Visual Feedback

• Added colored terminal outputs - In an effort to make verbose logs easier to scan.

• Status display with box-drawing characters (—status command) - For easier status reading at a glance.

• Interactive config menu (—configure command) - Selecting your log level now takes significantly less key strokes.

• Processing spinner animations for long operations - No more guessing about whether or not it’s crashed, or just thinking.

• Success/Error indicators baked into color scheme - Quickly scan error logs with ease!

v3.0.1 → v3.0.2 (Graphics Polish)

• Fixed terminal compatibility issues - Status and Config graphics weren’t displaying in the terminal correctly.

• Improved color schemes - Changed color hex values slightly to be more easily distinguishable.

• Better error messages - Made error messaging more descriptive of the actual error, rather than simply noting an error has occurred.

• Refined status display formatting - Fixed some minor issues with how the status box was drawn when called.

v3.1.0 (Dual Logging)

Major Update - Smart Debugging

• Split logging: Console (quiet) and File (detailed) - All logging is now silenced by default, allowing you to opt-in if you find the need.

• 3 new MCP tools added:

  • get_status - System status dashboard

  • configure_logging - Adjust configured log level

  • get_logs - Retrieve session history

• Logs automatically saved to ~/.durandal-mcp/logs/ - Creates timestamped log files, rotates in a new file every 10MB, only keeps logs for 7 days.

• Fixed debug message bug - Debug messages weren’t being written even when file log level was set to debug.

• Added input validation - configure_logging now rejects options that aren’t on the list. No super-debug for us, I’m afraid.

v3.1.1 (Documentation Polish)

No Functionality Changes, Just Better Documentation

• Updated all documentation to be more terminal and browser agnostic.

That just about does it for the state of the product at the moment. Remember when I mentioned adding polls? Here’s the first of them:

If you selected “something else“ please make sure you leave a comment letting me know what you’d like to see!

Leave a comment

But Why Though?

It’s simple, I want to give you the best product I possibly can. In order to do that I need feedback. In order to get feedback, especially when something breaks, I need logs to help determine the issue and push a fix as soon as possible. My goal with these recent updates has been user burden reduction and UX improvements in general. I’m trying to make bug reports and feedback as easy to communicate to me as possible.

So, What’s Next?

I know this has been a rather short article given the work that’s been done but, in all honesty, the changes made were pretty simple QOL adjustments to make Durandal easier and more comfortable to use.

As for what’s next: I’m not sure yet. I’ve got a couple directions I could go with Durandal in the coming weeks. I’m looking into potentially switching the DB type from SQLite to PostgreSQL to enable much larger datasets and much better handling at larger scales, as well as possibly refactoring the schema to match the same goals. I’m also considering finding a way to widen the scope of Durandal. I’m thinking it might be a good move to expand Durandal to be compatible with other AI providers as well, in the event Claude Code isn’t your go-to. I’m not sure how difficult this will be, or if it’s even possible, but I aim to find out in the coming days. Please let me know if either of these ideas appeal to you, and if not, what other ideas you have for Durandal!

As always, I thoroughly encourage you to break Durandal as hard and as often as you can. Feedback is appreciated, negative feedback is specifically requested. The sooner I know what you don’t want, the sooner I can fix it!

Final Thoughts:

If you’d like to give Durandal a try, the installation process is as easy as it gets:

If you’d like to review the code before installing, it can be found here: https://www.npmjs.com/package/durandal-memory-mcp?activeTab=code

For a global install: npm install -g durandal-memory-mcp

Then configure (on Windows) with: claude mcp add durandal-memory “cmd /c durandal-mcp”

or, for Unix/Mac: claude mcp add durandal-memory “durandal-mcp”

Important note: All commands above must be entered in the regular terminal/cmd window.

If you want more information on the install process, or about Durandal in general, please see the previous article here:

Super Secret Section (Shhhhhh!)

If you’re enjoying Durandal or this newsletter, consider subscribing! I plan to have at least one of these up per week, with the potential for more if several updates happen all at once. You won’t be spammed (I don’t have that kind of time), and I’ll do my best to deliver you news and updates in a swift and orderly fashion!

Thanks again for all the support out of the gate, I cannot express to you how much I genuinely appreciate it.

Hope to see you again soon!

About four months ago I started learning AI vibe coding with my father. I loved it, it was truly a marvel of modern technology. But when I began working with it myself I felt kind of put off by having to constantly remind, and correct, the marvel of modern technology about the current project IT built. I mean, seriously, what good is an All-Thing with amnesia?

Don’t get me wrong, it’s an exceptionally useful tool. One, rather seriously, equipped to handle large tasks, but nearly criminally handicapped by the incessant need to be reminded. If you’re like most people, the story ended there for you. You’re a busy person, you don’t have time to solve these issues. Plus, someone else will solve it for you in a few months, right?

Well, my friend, I am supremely unemployed and it’s been a few months. I present to you: Durandal - The Persistent AI Memory System designed to keep you more employed than me. (Hopefully..)

The Big Deal:

I’m certain you have at least one (1) burning question for me at this point, so I’m going to do my best to answer ahead of time to save you the typing. Besides, you need to save those key presses for copy/pasting npm install -g durandal-memory-mcp right?

Why does AI memory matter?

It’s simple, really. I hate reminding the computer of the things I already told it, you hate reminding the computer of the things you already told it. I am a simple man with simple problems. — Really though, let’s talk big projects here. Do you love using Claude Code as a tool for your hobby projects? Don’t you wish you could integrate it into your personal or team workflow at work? But that pesky memory issue would have you and your team wasting so much time, getting frustrated, and generally being unproductive during [BILLABLE] hours! Durandal allows you to host all of the project’s relevant information, edits to the code base, to-do lists, and more, all on-prem. Everything you need Claude to remember, stored locally, rapidly accessible to you and your team, all completely integrated into the Claude Code terminal you’re already familiar with. Already sounds pretty sweet, I know, but there’s more.

The Journey:

Look, I’ll be honest: nobody ever reads the “How Did We Get Here?“ sections of newsletters, but I’m obligated to write one for the AI overlords to determine my article is worthy of promotion. I’ll keep it light for your viewing ease, I promise.

I started development with lofty goals. Most of which have remained unrealized, as most first goals do, because it was wildly over-complicated. I’m a man of graphs, they help me understand what I’m doing. So when I started the Durandal project I realized almost instantly I did NOT have enough whiteboard for this project. One 4’x8’ sheet of white Melamine nailed to the, previously unmolested, wall of my house later and I had my whiteboard. Once I hit that point it was a wrap for the problem, who can stop a broke dude with a whiteboard? Nearly four months of development, and three entire product rebuilds, later I released Durandal v1. Now, you’re reading this and I’m out of ‘story-telling‘ patience. What more can I say? Most of it was a caffeine-fueled, late-night, frantic fixes endeavor. That’s not news to us developers..

The Solution:

Now that the boring part is over we* can have some fun!

Durandal, as I have yapped about at length, is an exceptionally lightweight MCP server. Once you install the package and run the config command to hook it to your Claude Code install, it’s as easy as continuing to use Claude Code in your current workflows. Durandal exposes a handful of tools (4) to Claude Code, henceforth referred to as “CC“ (I am lazy and you’re bored of reading it), to imbue it with the gift of persistent long-term, medium-term, and archival memory. Think of it as a waiter at a high-dollar restaurant. The waiter has a platter of “Hot“ memories ready to serve Claude, a rolling tray of “cold“ memories nearby, and some memories it can check for “in the back“. While you’re conversing with Claude, Durandal is actively swapping in hot memories to aid in Claude’s contextual grasp of the conversation. If you ask Claude about a specific topic you spoke about recently, Durandal will go get it off the “cold“ memories tray. If you need to reach really far back into the projects history you need only ask Claude and Durandal will happily waltz into the walk-in freezer for you. It truly feels like magic.

*”We” meaning you surviving five readers and myself.

However, at the end of the day, Durandal, and at length CC itself, are only force-multipliers. They are tools. When my Dad explained the idea of force-multipliers to me I gave him an analogy I think is fitting here: When you need to drive in a nail you reach for a hammer. You don’t try and slam it in with your hand, you can’t do that. But with the addition of a stick with weight on one end you can drive in hundreds of nails a day. Nearly everybody has had to think about putting a nail into something at least once. Almost everyone who hasn’t put a nail in something failed to do so due to them lacking a hammer.

I feel this is highly applicable in this context. Durandal isn’t a complex tool. It’s not a lathe or a table saw or an impact gun. Durandal is a hammer. A tool so simple a backwater yokel like me could think of it and build it, but one with such distinct purpose it’s virtually inseparable from the problem it solves.

Durandal and YOU:

If you’re hoping for a long, drawn out, complicated method then you’re insane then you’ve come to the wrong place. Durandal can be installed in a single command and configured for the low, low price of an additional one (1) command. After that point, as much as the cliche pains me, it Just Works™. Durandal is automatically launched on CC startup. All tools are automatically exposed to CC, and it can begin using them instantly. The database for storing memories is installed, built, and has a schema applied all by the install and config commands. Zero user management required.

What Makes It Go:

The Durandal system is driven by two layers of code separated by a handful of .js scripts. I said it’s dead simple.

The Database Layer

There are two parts to the DB level:

1. Storage Process:

   1. Content goes in the content field

   2. All smart categorizations go in in metadata as JSON

   3. System automatically adds importance scores, keywords, categories

2. Search and Retrieval:

   1. Uses SQLite’s JSON functions: json_extract(metadata, ‘$.project’)

   2. Full-text search on content: WHERE content LIKE ‘%query%‘

   3. Metadata filtering: importance, categories, project, session

The MCP Protocol Layer

The MCPI, or Model Context Protocol Interface, exposes four tools to Claude Code:

1. store_memory — This tool allows CC to store content with metadata in the DB

2. search_memories — This allows CC to search the stored memories with content, context, and other metadata filters

3. get_context — This gets recent memories and stats on the memories

4. optimize_memory — Finally, this tool can be called manually or by CC to optimize the way memories are being stored. Think de-fragmenting your hard drive.

That’s it. It’s that simple.

Of course as time goes on there will be updates, I’m pushing an update to the NPM registry as I’m writing this, so if you take a look and don’t like it, just give me a week. There will always be something new.

Practicality:

Look, like I said earlier, you’re a busy person. You don’t have time to be adding new tools and toys willy-nilly. So let’s go over how Durandal can help with your job and/or projects.

I used to work in the Electronic Health Records industry, so I’ll start there:

Let’s say you’re a developer working on enterprise level software for the EHR company you work for. You know you can speed up your productivity and free up brain power by using AI assisted coding. But there’s just one issue: the AI can’t see nor remember the entire code base all at once, let alone the chunk you’re working on. This is unacceptable, you can’t have AI working on your code with you in that state, you can’t be certain it won’t write code that conflicts with existing code you have just written because it can’t see it or factor for it. This is where Durandal comes in handy. With Durandal, CC can store the chunk of the code base you’re working on, or the entire code base, in its memory. It can then provide CC with the tools to intelligently parse, recall, memorize, and analyze everything it needs to make intelligent decisions as quickly as possible.

Let’s say, for the next example, you’re a power user, working on the next big thing on your home lab. You’re just one, maybe two lone developers working on your project. I can speak from personal experience when I tell you CC accelerates single-developer development by a mind bending margin as is. While Durandal doesn’t directly effect the speed at which CC processes information, it does allow for quicker reads, which lead to quicker writes. Small improvements, on a project scale, collect rapidly. Durandal prevents CC from having to parse files directly, as all files saved to its memory are parsed automatically, and metadata flags are assigned in memory to help CC parse and locate the portion of the code it needs to work on much more efficiently. These metadata flags include file content, semantic assessments, and context clues to guide CC to make better decisions, faster.

How Do I Start?

It’s quite simple — no really, I haven’t been lying to you. Check this out:

Durandal Installation:

If you’d prefer the ease of use of the NPM Registry, click here to view Durandal’s listing: https://www.npmjs.com/package/durandal-memory-mcp

If you’d like to review the code before installing, it can be found on this page on the NPM Registry: https://www.npmjs.com/package/durandal-memory-mcp?activeTab=code

To install Durandal you must first install Node.js. I know, I know, it’s a per-requisite we could avoid, but then you’d have to do a lot more steps. Once you have Node.js, it’s as simple as an NPM install command. (If you’re using Claude Code you probably have Node.js installed anyway..)

The command for a global install is: npm install -g durandal-memory-mcp

or, local install: npm install durandal-memory-mcp

Then configure (on Windows) with: claude mcp add durandal-memory "cmd /c durandal-mcp"

or, for Unix/Mac: claude mcp add durandal-memory "durandal-mcp"

To verify installation success you can use the following commands:

• Test that it’s installed and working: durandal-mcp --version

• Run built-in tests: durandal-mcp --test

• Check with CC to ensure it sees the installation: claude mcp list

• Launch CC with: claude

• Test CC’s connection to Durandal with: /mcp

Important note: All previous commands have been entered in the regular terminal/cmd window. The /mcp command must be run in the CC interface.

That’s it! You’re set up and ready to go. The MCP server runs automatically in the background. It's zero-config - using SQLite with automatic database creation at ./durandal-mcp-memory.db.

So What Do We Do Next?

This section is for future plans for Durandal. It contains very realistic plans and semi-reasonable hopes and dreams.

I fully plan on adding tons more functionality. I haven’t played with it yet, but earlier today (as of writing) Visual Studio Code released an MCP server integration. I’d really like to play around with that to see if I can get the gap between your AI assistant and your code base even smaller.

I’d like to add a simple UI for users to easily view their stored memories, but I’ll admit I have a lofty goal for this. I want Durandal/CC to be able to generate a mind-map of all of the saved memories, with graphical indicators displaying the connection and connection strength between memories. I’ll be honest, I don’t know what use case there is for this functionality, but it sounds cool, and that’s good enough for me.

I fully plan on adding functionality for users to directly inject memories into Durandal, as well as edit them, completely independently of CC. This is one of those things that sounds easier than it is, BUT I think it’ll end up being worth it, especially when dealing with large scale automation workloads.

I have a couple more ideas, but I don’t know if they’re possible yet that’d just spoil the surprise wouldn’t it? If you have ideas or feedback on the ideas listed above, please email me at stephen.leonard@entdna.com. Your opinions, and criticisms, are always welcome.

Wrapping Things Up:

So far, I am incredibly happy with where Durandal is in its development. It’s not fancy, but it does exactly what I want it to do. Before you can build a house, you must first build the foundation.

I thoroughly and genuinely suggest giving Durandal a try. There is no gimmick, there is no gotcha, there is simply a tool that works. Install it, play with it, tell me what you like, don’t like, and what you’d like to see in the future. Good software isn’t written by one person, and I’m very aware of that. That’s why I need YOU to hammer on it as hard as you can. I want you to break it. The sooner you can break it, the sooner the software improves for everyone. Obviously, Rome was not built in a day, but Rome was also not built by one guy. Rome’s engineers had teams of brilliant minded people around them to fall back on, I don’t. If you’re still reading this far you’re obviously interested, and almost certainly have a more brilliant mind than me. I’d love to hear your feedback.

Most importantly: Have a good time. I could not have built this tool if I didn’t thoroughly enjoy the process of making it. If you don’t like CC or the idea of utilizing newer software, just hang on for a little bit and check back in when you feel ready. At the end of the day you want good software and I want to make good software, but I can’t do that without good, intelligent, verbose, competent, and decipherable bug reports submitted by you.

Thank You, Genuinely.

No, seriously, thank YOU!

I cannot express to you in words how much I enjoy your support and willingness to help out. If you’ve made it to here and are considering installing Durandal, I would love to hear from you. Thank you for putting your trust in a lone developer and his software, I will do everything in my power to ensure you’re as happy with the product as I can make you.

Check in every now and then for more updates!

I hope you enjoy it, and I hope you have a wonderful day.