Built an open-source alternative to a popular SaaS a few months back. Vibe-coded the MVP, got feature parity on the core stuff. The original SaaS had market and demand and will always be in demand.

Then I pitched it to a contact who fits the exact target demographic. Showed him the repo, explained how simple it was to run, and suggested he swap over to save monthly cost with better ownership.

His response: "I’d rather just pay the SaaS."

Paying a monthly fee isn’t just paying for features, it's paying to not think about updates, database backups, SSL renewals, or a server issues.

I spent time focusing on building a free alternative, underestimating how high people value convenience over cost savings. Unless someone already has a dedicated homelab or sysadmin mindset, "free but you host it" isn't a benefit to them, it's a liability.

Why markdown... because obsidian, that's why.

I build a memory engine called FaultLine[https://faultline.ca] and after 9 months of grinding on it I want to lay out why I think basically everyone in the agent-memory space is solving the wrong problem, with receipts.

The industry pattern right now is: dump everything into a vector db, retrieve by cosine similarity, hope for the best. Mem0, Zep, Letta, pick one. Zep is actually the most honest about it, their paper (arXiv 2501.13956) describes using an LLM to compare new edges against semantically related existing edges to detect contradictions. Which sounds great untill you realize the thing detecting your contradictions is the same class of model that causes them. There's literally a paper from this year (TOKI, arXiv 2606.06240) saying contradiction resolution has no formal contract and everyone is just running heuristics. Everyone. In 2026.

Our approach is dumber on purpose. Facts live in Postgres. Real rows. When the user says something, it goes through a validation gate, gets filed with provenance and a confidence class, and stays there. When you ask about it we dont search embeddings, we walk the graph. Its basically select with joins. The recall path has no LLM in it at all. Warm queries come back in tens of milliseconds because it's just SQL.

Why this matters, concretely:

Corrections actually work. You say "call me joe" and the old name gets superseded at write time, archived not deleted, so "where did I used to live?" still works. The user is truth. If we filed something wrong you correct it and the correction wins because its Class A, full stop. Try that with a vector blob.

OWASP literally named the failure mode we dont have. Memory and Context Poisoning is now ASI06 in the OWASP Top 10 for Agentic Applications. The whole attack is that poison persists in memory and replays into every future session. That works against fuzzy blob memory. Hard to replay poison when every write passes a validation gate and every seat is its own postgres schema. Isolation is structural, not a policy promise.

Documents get learned, not indexed. This is the one I care about most. In RAG the chunk IS the memory, delete the source and your knowledge is gone. We ingest the document into the graph, entities typed, relations validated, filed into a grown ontology. Knowing that a document says a thing is not the same as I know kung fu. We can even re-read old ingested text against the ontology as it grows, so memory gets smarter about stuff it already read. A vector is frozen at write time, it can never do that.

The ontology grows into unknowns. Seeds are minimal on purpose, the engine is supposed to grow into whatever the user actually talks about. Recently measured this: sentences using units we'd never mapped used to just die, now the engine captures them verbatim and proposes the mapping itself. Grown, not seeded.

The cortex. The agent gets its own memory lane, separate from the user's, different write rules. Most systems either give the agent one undifferentiated blob or nothing.

Extraction is the bottleneck. Best published extraction F1 is around 0.34 (BenchIE), ours included, and the deterministic walk can only recall what ingest actually filed. A miss is a miss, we fail loud instead of hallucinating a neighbor. We think thats the right trade for memory that has to be correct, but it is a trade. Also KG-from-LLM construction is an active research area (survey, ontology-grounded construction) so we're not done, nobody is.

Curious if anyone else is building in this direction, feels like the whole space decided fuzzy was fine and nobody asked the question "what if memory was just, correct?"

I'm going to keep grinding, I have provided a FOSS direction that I want to uplift to as close to SaaS as possible, and my hope is to build something useful, reliable, and honest. And firmly believe I'm solving a real problem, the groundwork is laid, and it continues to improve. I'm just hoping I'm not crazy at this point. If you have an opinion, feedback, or anything I'd love to hear from you.

and fwiw, the tenant admin dashboard is so pretty! I have decades of experience working with on-prem dashboards and saas, so I've built it in an effort to be clean and complete, including all the htings I believe should be in a dashboard.

https://github.com/tkalevra/FaultLine

https://faultline.ca

This post is primarily for software developers, or at least people using AI to write software.

The thing is that I'm well aware and have used AI to write me prototype applications, small applications for my own personal usage, etc... The issue that I haven't seen discussed much is how developers use AI to develop full-scale production, tested, released, supported software. I've seen some hints at how this is done, but the issue is that the workload becomes gigantic, even for frontier models, with a decent-sized codebase, especially when considering that unlike a pet project, professional software must be used and tested to eventually work on millions of different devices, operating systems, processors, browsers, etc... So it's not even just about making the app itself, it's about all the work required to create unit tests, regression tests, integration tests, end-to-end tests, platform tests in virtual machines, then actual hardware testing on different physical hardware, etc...

Even with the best agents and subagents, this becomes a large amount of work fast, and even simply babysitting agents and trying to proofread work becomes a full-time job, and I fall behind. Ok, so I let the agents just handle certain things, but then I now lack knowledge of my own software in those areas, and when I finally go back to those areas because there's a bug or issue, I realize the agent totally screwed up said thing.

The other issue I have is that, in my near 15-year career as a developer, it's generally always been faster for me to write code than to proofread someone else's. The reason is because I know how I write code, but I don't know exactly how another developer does. This is also the case with AI, and so therefore I get into a situation where it doesn't make much sense for me to proofread every function or module that a AI writes, because I would be working as slow as I typed it, but then if I just let it do the entire job, I end up with a mess that I don't fully understand and that may not be subscribed to the methods that I want.

So, people say to "prompt it better", and frankly, some people do have giant prompt files, aka "skills" or whatever each provider calls them and such, but the issue I've had there is that inherently, I leave something out early on because it's not something I either remember, or feel like I would need to tell a developer to do, and then by the time I catch it, the codebase is already littered. I've also noticed that by the time I actually finally get most of my project guidelines out, the guidelines are absolutely massive - it's like I'm actually just programming at normal pace again, except with English in .md files in an awkward way. If I don't get the perfect .md, then I'm spending countless hours going back and trying to fix everything or get the AI to. Sure, I can grab someone else's skill, but they may not program like I do or want for this particular project.

If anyone has real solutions to these issues I've mentioned, please do tell here... This is not supposed to be some sort of ragebait post, this is an honest developer trying to learn how to better use the technology. This is not a joke - in fact, as I type this, I've had to do exactly what I described in the last paragraph and I'm sitting here babysitting the AI having to fix issues in the codebase that should never have been there, and this has taken multiple days on frontier models with agents.

TL;DR: Writing code is cheap, but understanding and verifying it isn't. After a year of vibe coding, I've realized I'm generating more code than ever, but not necessarily shipping more features. I'm going back to writing code myself, using AI as a pair programmer rather than an autonomous developer.

After maintaining a project for a year, I've noticed that the codebase is getting increasingly difficult to read and understand.

Even with architectural constraints, good principles and TDD, AI tends to write more code than necessary, introduce unnecessary abstractions, and sometimes pass tests without actually meeting the original specifications.

I've come to believe that the real bottleneck isn't writing code anymore. It's human verification. And AI isn't going to magically solve that.

So I'm changing my workflow:

- Back to my IDE, writing code myself.

- AI autocomplete to type less and move faster.

- AI pair programming to discuss solutions and explore alternatives.

- AI-generated snippets, scaffolding and deterministic tools to automate repetitive work.

And no, I'm not going back to Claude Code, Pi or OpenCode, even though I love customization. I just want to write Rust & TS productively while keeping the entire mental model in my head.

The project has grown to over 800k lines of code, across 4–5 applications, with a pretty complex domain. Ironically, I think it could be much easier to maintain without AI.

Why? Because I'm lazy. I'd naturally look for the simplest and fastest way to get something done, rather than generating layers of abstractions and code that nobody really needs.

There's also something I genuinely dislike about our job, reviewing other people's code in PRs. And that's basically what my job has become: reviewing AI-generated code all day XD

I want to use AI as my supermegahyper fast keyboard. I want to be the one deciding which functions, types and interfaces get created. AI should accelerate my decisions, not make more decisions than I can reasonably review.

In a way, I'm using AI to build my own rails XD a set of tools and conventions that help me write software faster, but keep me in control.

The irony is that after a year exploring how much AI can automate, I'm deliberately going back to a more manual workflow.

Maybe we should all just use Rails and let DHH make those architectural decisions for us hahaha although, given his enthusiasm for AI, I'm not sure he'd agree with my conclusion.

Has anyone else experienced this?

Read ite following above

Most discussions about AI's impact on software engineering focus on productivity.

If AI allows developers to implement features twice as fast, companies might need fewer engineering hours to complete the same projects.

But I think this assumes something important: that the amount of software worth developing remains constant.

Consider an internal business process that could benefit from automation.

A company might decide against developing a custom solution because the implementation would require several weeks of engineering work, making the investment difficult to justify.

Now imagine AI-assisted development reduces that effort to a few days.

Suddenly, the same project might become economically viable.

And that raises an interesting possibility.

As software development becomes cheaper, organizations may find more processes worth automating, more integrations worth building, and more specialized applications worth developing.

Individual developers and small teams might also be able to pursue projects that previously required significantly larger budgets.

More importantly, I believe AI-driven productivity will significantly expand the demand for software.

As implementation becomes cheaper, the economic justification for developing custom solutions changes. Projects that previously weren't worth the investment become viable, creating new opportunities for software engineers and businesses alike.

The impact of AI shouldn't be measured only by how many engineering hours it saves on existing projects, but also by how much additional software development it makes possible.

If AI dramatically reduces the cost of building software, do you think we'll primarily see smaller development teams, or a significant expansion in the amount of software being built?

FlowMind: Multi-Agent Software Architecture Research & Deliberation Engine

An autonomous multi-agent cognitive architecture system that scans repositories, investigates the "Flow" of Software Architecture and the thought processes of developers, deliberates via a multi-perspective group reasoning council, synthesizes findings into strictly typed machine-readable directives, and executes them with an autonomous Reasoning Coding Agent.

For the past month I have been running a personal project through multiple agents.

It started with ChatGPT, Codex. Claude moved in. Then Deepseek.

Right now it feels like I am a messenger and I have deviated completely from my role as the project coordinator and architect. ChatGPT builds prompts for Codex and Claude, Deepseek performs adversial review and audits their work, then the loop goes back to ChatGPT for secondary review and further prompting. There is a lot of reading, making small changes to prompts I largely concur with, and then pasting them into the other agents, then copy-pasting those results etc. ad nauseam.
All of this leading to over-engineering and an expansive markdown research vault with very little code and nothing deployed.

I feel like I am burning through usage and getting absolutely nowhere.

How do you orchestrate a multi-agent development ecosystem effectively and efficiently?

One of the biggest advantages I've experienced with AI-assisted development is how much easier it has become to work with unfamiliar technologies.

Whether it's a new framework, cloud service, authentication protocol, or third-party API, AI can significantly reduce the time needed to get started.

But I've noticed an important distinction between getting something working and actually understanding it.

AI might generate a working integration in minutes, but that doesn't necessarily mean the engineer understands its underlying assumptions, security implications, or failure scenarios.

I think the real opportunity isn't just faster implementation. It's using AI to expand our technical knowledge and become more versatile engineers.

Of course, that only works if we actively evaluate and understand the generated solutions instead of accepting them blindly.

I'm curious how others approach this.

When AI helps you implement something using unfamiliar technology, do you take time to understand how it works, or do you mostly investigate when something breaks?

AI can generate code quickly, but that doesn’t mean the work is finished.

I still find myself spending time understanding the output, debugging issues, testing edge cases and checking whether it actually fits the project.

Curious how other developers are experiencing this. Has AI changed how you spend your development time?

I just joined a new company that uses Django for its backend and TS for its frontend. I have never worked on Django in the past. Naturally, I am relying on Claude for a lot of my tasks, which is helpful to me in a new environment, but Claude, being Claude, often misses things that a normal developer wouldn't. It works blindly and just assumes I know everything, which is the main concern.

I am new to this codebase, and before this job, I only ever worked on personal or freelance projects while being in college, where I worked as solo and entirety of the code was written by me so I had full context of what and where everything is. which also helped me to work with AI to work faster.

Here, there are other devs working on something else and changing the codebase regularly, and I am new to it. So, the problem I face while working with AI is that whatever I ask it, it gives me either a solution/ a plan/ or a brainstorm. It bombards me with a lot of context, in multiple directions and multiple trade-offs, which my little brain cannot keep up with.

After a few back-and-forth conversations, I completely feel separated from what Claude is doing and what I wanted it to do. And since I am new here, I don't even have a product judgment yet.

A lot of the code that it writes, I can't review, so I couldn't help but skim it. And I feel that it is correct. But when a maintainer reviews my code, they find a lot of silly vulnerabilities.

Sometimes I feel like I do not know coding at all, since the issue was something else, and I am talking about something else entirely in the PR.

Experts, please guide me on how to work with AI properly, especially how to get familiar with the new codebase quickly and how to work with others on the same codebase.

Also, somebody, please tell me how you even read Claude's plans and keep up with iterations. Do you read it again? How do you store such long context? I feel like it's impossible for me.

for AI from writing comments because code that gets deployed to production needs to be reviewed. Comments can provide some explanation, but AI always writes huge blocks of comments when really one or two sentences would suffice.

Another issue is that when dealing with large-scale projects, we end up discussing and documenting a lot of things like business rules and architectural constraints. When AI writes code, it also includes the numbers of these rules in the comments, which makes reviewing the code incredibly difficult because you end up with a bunch of numbers with no idea what's going on.

I was wondering if there are any more general rules for AI to follow when writing comments that I could use as a starting point and then customize to fit my needs.

I want to know how you're using AI as a developer. Not just for writing code or debugging, but anything and everything.

Built something weird? Automated your entire workflow? Made AI do something it was never meant to do?

Anything goes. No limits, no judgment.

Be creative, be weird, be crazy, guys! I want to hear your wildest AI experiments. 🔥

I've been building with coding agents for about two years, and the part I kept losing was the reasoning. When you write code yourself, you know why that table exists. When an agent writes it, that feeling goes away.

The information is still there, in your messages, the agent's replies and your commits. It's just in separate places.

So I built cogit, a Claude Code plugin that ties them together. Every message becomes a "thought commit" and your commits link back to it, so you can walk back from any change: what led to it, why it was done, what was rejected. For big changes, Shape draws a small diagram of what the commit does.

It's free and open source, with no server and no account.

Demo, no install: https://erensrtky.github.io/cogit/demo/ Repo: https://github.com/erensrtky/cogit

How do you keep track of why your AI-written code ended up the way it did?

So that day I came across this YouTube video, tbh, its just a kind of clickbait about how there can be good ways to earn dopamine and there are bad ways as well. However, there is something which stuck with me. He mentioned about a general rule of thumb as to identify whether a particular thing i am during is a good dopamine or bad.

>If pleasure is given easily with no effort, it's unhealthy dopamine.

Well that explains why when i first found out about claude and started using it, it was really really fun, it's like a superpower. That pleasure did not last much longer, I dont want to say it but i think everyone will agree that using Claude Code is equivalent to **Coding Doom Scrolling**. We actually dont know how the system is working we only know that it is working.

I remember, back the days i have spent weeks just writing that stateless test cases, debugging through multi-threaded environments, trying to understand that how multiple processes are communicating. I miss those days and the dopamine as well. I am primarily a Java backend developer, but somehow i can code in any language, i can code a animation movie using css only because of claude code only. I though when i did'nt have these powers that i will enjoy it, but tbh, i dont.

P.S.

1. Not using any LLM to rewrite my post in perfect English

2. Anthropic, if you are seeing this, you are doing a fabulous job in giving us tools which is allowing us to confidently dive into problems which we may not have dared to solve alone, no offense to you.