In my 30+ years of SWE/SWA career this is the first time I can harvest the benefits of a well defined and exactly implemented architecture.
Thanks to LLMs.
Before LLMs even if the architecture principles were simple and clear, distilled into templates + codegens added for boilerplate / skeleton generation ... It was impossible to follow them on the long run. Devs tried their best, but on the long run everything eroded and there were no resources for refactoring.
Now, with coding agents, I was able to create a production grade app following a similar architecture to Presentation Domain Data Layering, from this article.
Now the codebase is 100% uniform both in content (code) and structure (files and folders). It's like being written by a single person. Finding a specific file takes a second with no cognitive load. Editing a file is straightforward since every file follows a specific template.
LLMs have benefits and drawbacks, and in this case their help is enormous.
Good point! Reviewing code, in the AI era, in my practice, means skimming code and looking for patterns.
I use templates / conventions and make the AI generate code using them. When reviewing code I'm scanning if a file uses a specific template and follows specific conventions.
This can't catch subtle errors like a function is re-created vs is re-used (duplicate code), unnecessary code (bloat), inconsistent naming (a Button component has a cssRow() styling function associated vs cssButton()).
When you start editing, using code these little things add up, consume your attention, drain you up, giving no flow and resulting in minimal productivity.
This specify-encode-fulfill loop/method is effective to make agents create bug-free code.
In my version of this workflow I do specify myself, then let the LLM do the rest.
This way 1.) I'm 100% sure the understanding/spec is good 2.) It's translated into an executable format so the implementation can be verified 3.) The implementation has maximum code coverage tests which steers the AI to produce code which follows standards, fits into the existing codebase, and it's very easy to refactor.
So far, this is the one and only advantage of using LLMs in my SWE practice. They glue together (human written) specs with code, with confidence, in no time.
I'm not an ML expert, but regarding code _quality_ I see no progress at all in the last couple of years. LLMs still write code by using probabilistic calculations vs. applying rigorous thinking and logic.
This is only good while no one has to look under the hood. When trying to understand and fix code written by LLMs you'll realize what a mess they produce. It's a codebase without any systematic thinking inside. Everything is ad-hoc, wired together to pass the tests, and to conform to some templates. No deliberate practice, no intelligence at all in the code.
This can't be a long term strategy for an entire industry.
We _know_ LLMs can't be _that_ good as they are promoted.
I've spent the last 6 months creating a production grade app from scratch with Claude where I wrote no single line of code. I've reviewed code and it was looking good, almost completely following my templates, workflows, skills.
Now I've started to make minor manual updates and I'm horrified. Claude has no idea why there were those templates and instructions in place. It followed them blindly without grasping their spirit. The end result is like a very junior dev copy-pasting answers from Stack Overflow into the codebase. No consistency, chaotic application of different conventions, duplicated code, ghost code (does nothing), and perhaps more as I'm digging in.
The pros: The code works, all tests pass (43% code / 57% tests, 1:1.3 ratio), the UI looks good with visible glitches
The cons: I'll have to rewrite most of the code on the long run, make it fit, easy to maintain.
The verdict: I wouldn't started this project alone. Claude get me through to v0.1.0 / MVP where I've focused solely on the product: technologies, architecture, functionality, and usability. Now it's easier to refactor all for v0.2.0 manually without Claude.
So this might be our gut feeling: we know it's something good, but not as good as the stakeholders might promote. We know it helps in some ways but it's a nightmare in other ways.
We are not anti-AI but rather pragmatic: Not that AI enthusiasts we are expected to be.
Mathematics, Computer Science and UI/UX design specialist with 25+ years of experience.
I solve two of the most challenging software engineering problems: code organization and state management, using lightweight formal methods -- Applied category theory, Finite state machines -- to bring academic rigor to the full stack: https://www.osequi.com/studies/list/list.html
I'm a junior AI Engineer versed in prompting, agentic development with Vercel AI SDK. Finishing my first AI app, an agent/assistant helping to write likely-correct studies, articles and technical documents.
Seeking:
- Teams building better software, faster
- Particularly interested in fintech, health-tech, and developer tools
There are formal methods where the underlying model is mathematically sound. There are semi-formal methods where the underlying model is structured but not proven to be sound.
For example, in your case ("organizes knowledge") a formal method is ologs from category theory. That method assures that the concepts and their relationship in your knowledge base are mathematically correct.
When you want to transfer that knowledge base into a documentation system you might want look for a mathematically sound model, but I'm afraid there is no such model, so what's left is a semi-formal method / a likely-correct model.
Right now I'm building such a likely-correct model for writing, contact me for more info.
Perhaps there is no such thing like absolute truth.
In category theory / ologs, a formal method for knowledge representation, the result is always mathematically sound, yet ologs are prefixed with "According to the author's world view ..."
On the other way truth, even if it's not absolute, it's very expensive.
Lately AWS advocates a middle ground, the lightweight formal methods, which are much cheaper than formal methods yet deliver good enough correctness for their business case.
In the same way MIT CSAIL's Daniel Jackson advocates a semi-formal approach to design likely-correct apps (Concept design)
It seems there is a push for better correctness in software, without the aim of perfectionism.
The structure (ontology, taxonomy) is created with ologs, a formal method from category theory. The behavior (choreography) is created with a semi-formal implementation (XState) of a formal method (Finite State Machines)
The user-facing aspect of the software is designed with Concept Design, a semi-formal method from MIT CSAIL.
Creating software with these methods is refreshing and fun. Maybe one day we can reach Tonsky's "Diagrams are code" vision.
My prompt is ... "We are implementing the X feature. We are at step 6. Plan first"
Then the agent spits out identical plans then identical code for every feature.