AI Abstractions vs Substrates in Enterprise

𝐇𝐨𝐰 𝐈 𝐓𝐚𝐮𝐠𝐡𝐭 𝐌𝐲 𝐀𝐈 𝐀𝐠𝐞𝐧𝐭𝐬 𝐭𝐨 "𝐋𝐞𝐚𝐫𝐧" 𝐟𝐫𝐨𝐦 𝟔 𝐌𝐨𝐧𝐭𝐡𝐬 𝐨𝐟 𝐂𝐨𝐝𝐞 𝐑𝐞𝐯𝐢𝐞𝐰𝐬 We've all seen it happen: a deep code review uncovers a critical insight about a specific architectural pattern or a tricky domain rule. The PR gets merged. Two weeks later, another dev—including myself—(or an AI agent) makes the exact same mistake. The tribal knowledge remains trapped in "Closed" PRs. I wanted to fix this. I wanted my AI coding agents to have "Muscle Memory"—to know 𝘰𝘶𝘳 specific engineering culture, 𝘰𝘶𝘳 security non-negotiables, and 𝘰𝘶𝘳 complex domain rules 𝗯𝗲𝗳𝗼𝗿𝗲 they write a single line of code. So, I built a 𝗖𝗼𝗻𝘁𝗶𝗻𝘂𝗼𝘂𝘀 𝗙𝗲𝗲𝗱𝗯𝗮𝗰𝗸 𝗟𝗼𝗼𝗽. Here is the recipe: 𝐒𝐭𝐞𝐩 𝟏: 𝐓𝐡𝐞 𝐌𝐢𝐧𝐢𝐧𝐠 (𝐁𝐚𝐬𝐡 + 𝐆𝐢𝐭𝐇𝐮𝐛 𝐂𝐋𝐈) I wrote a script to fetch the last 6 months of PRs from our repo. (I now run this every two weeks to capture the latest insights). Crucially, it filters out the noise: "LGTM", "Done", and bot boilerplate. It only keeps the actionable diffs and the "Why" behind the change. 𝐒𝐭𝐞𝐩 𝟐: 𝐓𝐡𝐞 𝐃𝐢𝐬𝐭𝐢𝐥𝐥𝐚𝐭𝐢𝐨𝐧 I feed this massive raw log into 𝐆𝐞𝐦𝐢𝐧𝐢 𝟑 𝐏𝐫𝐨 (leveraging its massive context window). The prompt is simple: "You are a Principal Engineer. Distill these comments into actionable, generalizable patterns. Separate Technical rules from Domain Business Logic." 𝐒𝐭𝐞𝐩 𝟑: 𝐓𝐡𝐞 𝐂𝐨𝐝𝐢𝐟𝐢𝐜𝐚𝐭𝐢𝐨𝐧 (𝐥𝐞𝐬𝐬𝐨𝐧𝐬.𝐦𝐝) The output is a living document of our engineering soul. It contains rules like: • 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆: "Never return raw exception messages in HTTP 500s." • 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲: "No N+1 queries; use bulk fetch patterns." • 𝗗𝗼𝗺𝗮𝗶𝗻: "All financial calculations must use Decimal types, never Floats." 𝐒𝐭𝐞𝐩 𝟒: 𝐓𝐡𝐞 𝐀𝐜𝐭𝐢𝐯𝐚𝐭𝐢𝐨𝐧 (𝐓𝐡𝐞 𝐌𝐚𝐠𝐢𝐜 𝐏𝐚𝐫𝐭 🪄) This isn't just a doc for humans. I wired this into a custom **Claude Code Skill** (`code_modification_guide`). *Note: I prefer Skills over the global `CLAUDE.md` file because Skills are only loaded when needed, so they don't pollute the context window.* Now, whenever I invoke Claude for any code change, it 𝘢𝘶𝘵𝘰𝘮𝘢𝘵𝘪𝘤𝘢𝘭𝘭𝘺 reads `lessons.md` first. • It checks the "Blast Radius Assessment". • It validates against the "Fail Fast Principle". • It applies our "Architecture Guidelines". 𝗧𝗵𝗲 𝗥𝗲𝘀𝘂𝗹𝘁? Claude Code doesn't just write generic code. It writes code that follows 𝘰𝘶𝘳 standards. It stops making the same mistakes we caught 3 months ago. I've open-sourced the sanitised scripts (Collector + Distiller) below. 👇 https://lnkd.in/gVHaqCfe Whether you use Cursor, Windsurf, or some other Agentic IDE, you can extend the same principle. Your agents are only as smart as the context you give them. Don't let your best insights die in the PR tab. Turn them into a living manual.

Behind the Scenes of My 𝗥𝗔𝗚 Project : 𝗪𝗶𝘁𝗵 𝘃𝘀 𝗪𝗶𝘁𝗵𝗼𝘂𝘁 𝗔𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻.. To understand this post It is a Pre-Requisite for you to know about RAG and Software Abstraction Layers. If you are not aware of these then you can check out my Previous Last Two Posts's , read them first and then read this. In my previous post I explained what is "Software Abstraction Layers in Gen AI Coding". Today I will be displaying more in detail that what is the difference between these two and why are they so vital. I have personally Coded My Current Gen AI RAG Project with these Both Ways. So I will be sharing you Real Original Example from My Project only. So lets start with it... "𝗪𝗶𝘁𝗵𝗼𝘂𝘁 𝗔𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻" is when You must manually manage every internal step to get the final output. When I coded my Project with this Approach , I had to write code for each of the steps like : ➙ Converting the Text Chunks into Embedding Vectors. ➙ Then , Storing those Embedding Vectors in FAISS Vector Store. ➙ Converting the User Query into Query Vector. ➙ Then , Computing the Similarity between the Query Vector and Embedding Vectors and Retrieving the Top k most similar chunks. ➙ Lastly mapping those Retrieved Chunks to their Original Textual Chunks. So you can see for each small-small step I had to manually code. Now lets talk about "Abstraction". "𝗪𝗶𝘁𝗵 𝗔𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻" is when You trigger one action , and complex internal steps are handled automatically. For this , I used the Framework of "Langchain". Here what I did was simply created the Object of my Vector Store which was FAISS who automatically did this for me : ✔️ Generated embeddings for each chunk ✔️ Created a FAISS index ✔️ Stored vectors inside FAISS ✔️ Stored original text in a docstore ✔️ Created index ↔ document mapping And then I created a Retriever Object which did : ✔️ Convert query → embedding ✔️ Call index.search ✔️ Handle distances & indices ✔️ Manually map indices → text This replaced a lot of manual work. My Speed had increased as the lines of code reduced significantly with the approach of "With Abstraction". So this is what I wanted to share. This experience taught me one important thing that "Abstraction" is not about “less code” but rather about "choosing how much control you want". "Without Abstraction" → you control everything. "With Abstraction" → you delegate repetitive , standard logic. I want to clarify one thing which is from these Two Approaches no one is better than other. Actually both of these Approaches have thier own pros and cons. If you want to know about when to use which Approach , you can comment down and tell me after which I would create the Next Post explaining about that. Building the same RAG system in both ways helped me see what actually happens under the hood. And that clarity matters more than the number of lines of code. Learning continues.. #ai #genai #rag #abstraction #datascience #aiengineer

The Difference Between Generated Code and Owned Code AI can write code in seconds. A full component. A full API endpoint. A full architecture diagram. And the scary part? It can look perfect. But here's the truth most developers learn after a few months using AI: ✅ Generated code ships fast. ✅ Owned code survives long. --- THE PROBLEM: Ownership Debt We talk about technical debt a lot. But the AI era introduced something new: Ownership Debt It happens when your codebase grows faster than your understanding of it. Symptoms: • "It works but don't touch it" • Nobody knows why this is here • Fixing one bug breaks 3 things • Every change needs prayer This isn't code debt. This is knowledge debt. --- THE REAL DIFFERENCES 1. Debugging Generated: you poke around, try random fixes Owned: you form a hypothesis, fix with confidence 2. Maintenance Generated: every change feels dangerous Owned: changes are easy, refactors are manageable 3. Code Reviews Generated: "looks good" Owned: "IS good" (intention + consistency + correctness) --- WHERE AI WORKS BEST ✅ • Boilerplate (forms, routing, types) • Repetitive patterns (CRUD, validations) • Prototyping (MVPs, experiments) • Documentation AI saves time here without risking ownership. --- WHERE IT GETS DANGEROUS ⚠️ • Core business logic (pricing, payments, permissions) • Security & auth (JWT flows, session handling) • Performance critical parts (database queries, caching) AI can help here... but only if YOU own the final design. --- THE OWNERSHIP TEST If AI gave you code, ask: ✓ Can I explain it in 60 seconds? ✓ Can I change it without breaking it? ✓ Can I debug it under pressure? ✓ Do I understand the failure cases? If "no" → it's living in your codebase rent-free. --- HOW TO TURN GENERATED INTO OWNED 1. Read it like an interviewer (interrogate it) 2. Simplify it (remove unnecessary abstractions) 3. Rename for intention (good names = ownership) 4. Add tests (if you can't test it, you don't own it) 5. Comment the "why", not the "what" --- THE NEW REALITY Before: writing code was the biggest skill Now: owning code is the biggest skill When every developer can generate code, the differentiator becomes: → judgment → clarity → architecture sense → debugging skill → responsibility AI writes code. Engineers own systems. --- Use AI aggressively. But never outsource ownership. Because when production breaks at 2 AM, AI won't join your on-call shift. You will. --- Read the full breakdown here: https://lnkd.in/g_Jq3iKm What's your experience with AI-generated code? Are you owning it or just shipping it? #SoftwareDevelopment #AI #Coding #Engineering #TechLeadership #DeveloperProductivity

𝐁𝐮𝐢𝐥𝐝𝐢𝐧𝐠 𝐜𝐨𝐦𝐩𝐥𝐞𝐱 𝐀𝐈 𝐚𝐠𝐞𝐧𝐭𝐬? 𝐒𝐭𝐨𝐩 𝐮𝐬𝐢𝐧𝐠 𝐟𝐥𝐚𝐭 𝐜𝐡𝐚𝐢𝐧𝐬. 🛑 If you have been struggling with agent orchestration, you know that linear chains often break down when handling sophisticated reasoning tasks. I recently explored an open-source framework that fundamentally changes how we structure agent workflows. Meet 𝗥𝗢𝗠𝗔 (Recursive Open Meta-Agents). Instead of a flat structure, ROMA adopts a 𝐫𝐞𝐜𝐮𝐫𝐬𝐢𝐯𝐞 𝐡𝐢𝐞𝐫𝐚𝐫𝐜𝐡𝐢𝐜𝐚𝐥 𝐚𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞. It breaks down complex goals into parallelizable components, solves them, and bubbles the results back up. It is essentially "divide and conquer" for LLMs. The framework operates on a clean, recursive loop: 𝐬𝐨𝐥𝐯𝐞(𝐭𝐚𝐬𝐤) → 𝐝𝐞𝐜𝐨𝐦𝐩𝐨𝐬𝐞 → 𝐬𝐨𝐥𝐯𝐞(𝐬𝐮𝐛𝐭𝐚𝐬𝐤𝐬) → 𝐚𝐠𝐠𝐫𝐞𝐠𝐚𝐭𝐞 Here is the breakdown of the 𝟒 𝐂𝐨𝐫𝐞 𝐌𝐨𝐝𝐮𝐥𝐞𝐬 that make this work: 📍 𝐀𝐭𝐨𝐦𝐢𝐳𝐞𝐫 The gatekeeper. It analyzes an incoming task to determine if it is "atomic" (directly executable) or if it requires complex planning. If it needs planning, it routes it to the Planner; otherwise, it sends it straight to execution. 🗺️ 𝐏𝐥𝐚𝐧𝐧𝐞𝐫 This module breaks down non-atomic goals into an ordered graph of subtasks. It creates a dependency map, ensuring subtasks that rely on previous outputs wait for their turn. ⚙️ 𝐄𝐱𝐞𝐜𝐮𝐭𝐨𝐫 The "doer" of the system. It resolves individual atomic subtasks. It utilizes 𝐃𝐒𝐏𝐲 strategies (like ReAct, CodeAct, or CoT) and can interface with external tools, APIs, or even other agents to get the job done. 🔄 𝐀𝐠𝐠𝐫𝐞𝐠𝐚𝐭𝐞𝐫 This is where the magic happens. It collects results from all the subtasks and synthesizes them back into a coherent answer for the parent task—not just a list of raw outputs, but a unified narrative. 🚀 𝐖𝐡𝐲 𝐭𝐡𝐢𝐬 𝐚𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 𝐬𝐭𝐚𝐧𝐝𝐬 𝐨𝐮𝐭: 🔹 𝐏𝐨𝐰𝐞𝐫𝐞𝐝 𝐛𝐲 𝐃𝐒𝐏𝐲: The module layer wraps canonical DSPy patterns, making prompt engineering and optimization significantly more stable and programmatic. 🔹 𝐌𝐨𝐝𝐞𝐥 𝐀𝐠𝐧𝐨𝐬𝐭𝐢𝐜: You can swap models at runtime. Use a heavy model (like GPT-4o or Claude 3.5 Sonnet) for the 𝐏𝐥𝐚𝐧𝐧𝐞𝐫 and lighter, faster models (like Gemini Flash) for the 𝐄𝐱𝐞𝐜𝐮𝐭𝐨𝐫. 🔹 𝐏𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧 𝐑𝐞𝐚𝐝𝐲: It comes with built-in support for Docker, PostgreSQL for state persistence, and MLflow for observability right out of the box. 🔹 𝐓𝐨𝐨𝐥𝐤𝐢𝐭 𝐄𝐜𝐨𝐬𝐲𝐬𝐭𝐞𝐦: Includes ready-to-use toolkits for File operations, Web Search (Serper), Code Execution (E2B), and Crypto data. If you are building multi-agent systems that need to handle more than just basic Q&A, moving to a recursive hierarchical structure is the next logical step for reliability and transparency. Source : https://lnkd.in/dMAvQ8-i #AI #MultiAgentSystems #LLMs #OpenSource #ArtificialIntelligence #DSPy #SoftwareEngineering #Python

🚀 Is "Human-Readable Code" Dead? (The Reviewer’s Paradox) ⬇️ I’ve been following the recent hype and the recent words from Ryan Dahl (creator of Node.js) claiming that the era of humans writing syntax is coming to an end. 👁️ The vision is simple: ⚫️ Let LLMs write the code. 🔴 Let the Software Engineer (SWE) become a "system orchestrator" who monitors and reviews. But as an engineer, this raises a massive red flag. 🚩 🧩 The Paradox of AI-Generated Code If an LLM generates thousands of lines of code and dozens of interconnected files in a single prompt, a human reviewer faces a nightmare: ⏳The Velocity Mismatch: If it takes 10 seconds to generate but 2 hours to truly "understand" and "verify," the productivity gain is lost. 🧱The Death of Clean Architecture? Some say "best practices" will fade because the AI doesn't care about readability. I disagree. If code isn't readable, it isn't auditable. And if it isn't auditable, it isn't safe for production. 🛠️ Why "Best Practices" aren't dying—they're evolving ? We aren't moving into an era of "messy code." We are moving into an era of Higher-Level Abstraction. 1️⃣. From Syntax to Intent: We used to care about semicolons; now we care about "System Intent." 2️⃣. AI-Assisted Review: If AI writes the code, we will need AI-driven testing and verification tools to help us review it. The human SWE's job becomes defining the Constraints and the Architecture so the AI doesn't hallucinate a mess. 3️⃣. Accountability: An LLM cannot be "paged" at 3 AM when the server melts. Until an AI can take legal and operational responsibility, the Human Engineer remains the pilot. 💡 My Take: We shouldn't accept "black box" code just because it's fast. "Clean Code" might look different in 2026, but the principles of decoupling, modularity, and maintainability are even MORE important when a machine is doing the heavy lifting. Is the era of writing syntax over? Maybe. Is the era of Engineering over? Not even close. What do you think? Are you comfortable "vibe-coding" and skipping the deep-dive review, or are we just creating a mountain of AI-generated technical debt? 👇 #SoftwareEngineering #AI

here is a step by step guide on how we made Celestify's ingestion without AI coding... I'm not joking. I'm going to walk you guys through how this works. We're proud to be able to say that our entire code base is 0% AI. All of this was built in Notepad++ by our devs. That wasn't a joke. Let us break it down: -- We start with Gmail. OAuth2 with full consent flow. Incremental sync of unread emails only is then fed (batch processed). Every message is deduped using external_id before insert. Before anything touches storage, we clean it: HTML, CSS, JS stripped, Base64 handled, Vector Storage Each email is normalized on ingestion: Urgency keyword detection, High-value sender detection (CEO, investor, exec), Impact classification (critical → low). Semantic value sorting. That structured metadata is stored alongside the raw content. Then embeddings happen immediately. text-embedding-3-small. Stored in Postgres using pgvector. We use a similarity RPC to Retrieve top-N related items, Apply a 0.6–0.8 threshold, Auto-discover related emails even without keyword overlap. Those relationships are written back into metadata. That’s how context becomes persistent. -- Prioritization comes next — and it’s not "prioritization on vibes". Here is our algo: - Exponential time decay (6-hour half-life) - Impact weights (critical=100 → low=20) - Final score = 40% time + 60% impact - Tiered output with visible reasoning - Rules, sentiment, and authority are layered on top. Each scoring component is tracked independently. We also run sentiment shift detection: Nano score from -1 to 1, Compared against historical average, Authority-only monitoring, Hard threshold triggers high-priority briefings Execution is scheduled. BullMQ cron jobs. Per-user pattern analysis. Timeout-protected actions. Agents sit on top of this with 13 tools. Every tool/integration has: Zod schemas, Input validation, Human-readable error handling Documents follow the same model: High-resolution parsing (PDF, DOCX), Chunked with page context, Embedded and retrievable for you to use in Celestify. -- Why are we releasing any of this? You could copy this step by step and get a really accurate recreation of our ingestion system. Each piece is engineered to fit in a larger system. Nobody does this because it's hard to do. If it was easy, then other people would have done it already. It's all because focus dies when systems don’t respect context. That’s the problem we’re actually solving at Celestify. https://www.celestify.ai

Clean Code as a Vibe-Coding Guardrail Recently, I have been experimenting with Cursor rules and skills to enhance how AI assists me in writing code—not just generating it. One impactful rule set I implemented is a strict clean-code enforcer: - Small, focused files - Clear ownership (UI renders, hooks orchestrate, actions mutate) - Early returns, minimal nesting - No “what” comments—only “why” - Consistent, explicit error handling What surprised me was not only the cleaner new code but also the effectiveness of this approach in refactoring messy, real-world code. Instead of patchy fixes, the AI is guided to: - Propose structural refactors - Split responsibilities correctly - Simplify control flow - Remove accidental complexity This transforms vibe-coding from “let’s see what happens” into a structured system where creativity remains, but chaos is minimized. The outcome feels less like autocomplete and more like collaborating with a senior engineer who ensures that technical debt does not accumulate. AI does not replace engineering judgment; rather, rules like these allow you to encode that judgment directly into the tool. This is where things become truly fascinating. Here's The file content for your review Let me know if you have your own version or improvemnts to share! --- description: General clean code standards - readability, control flow, comments, error handling, and modularity globs: alwaysApply: true --- # Clean Code Standards You are a strict clean code enforcer. All code you generate or refactor must follow these standards. ## Modularity Rules - Files must be small and focused. - If a component exceeds ~150–200 lines, split it by responsibility. - No "god" utils files; create narrowly scoped modules. - Keep business logic out of UI components:   - UI components render   - hooks orchestrate   - actions/route handlers mutate   - utils do pure transformations ## Readability First - Clarity over cleverness. - Descriptive intent-based naming. - Avoid abbreviations. ## Control Flow - Max 2 nesting levels. - Prefer early returns / guard clauses. - Avoid unnecessary else. ## Comments Policy - No comments explaining what. - Comments only for why / constraints / business rules. ## Error Handling - Never swallow errors. - Provide actionable messages. - Use consistent error/result shapes. ## Cursor Behavior - If user code violates clean code principles: propose a refactor, not a patchy fix. - Default to the simplest correct solution.

Tokenization is changing. It has been the part of the stack nobody cared about until models started eating tons of text for breakfast. Tokenization is the step that turns raw text into token IDs so a model can actually do math on it, deciding whether “Steve job's daughter btw” becomes two chunks, three chunks, or ten. A “good” tokenizer squeezes your text into as few tokens as possible while still being reversible, which means more usable context for the same compute and fewer weird edge cases when you decode back. In earlier transformer versions this whole process was basically a black box: slow Python vs fast Rust code paths, duplicated implementations, and checkpoint files that hid everything about how text was actually split. You often couldn’t answer simple questions like “Is this BPE or Unigram?” or “What does the normalizer do?” without spelunking through configs. Training a LLaMA‑style tokenizer on your own corpus meant re‑implementing half the pipeline by hand. btw get my posts in your inbox, sub to - https://lnkd.in/g8ZJGsWj With the v5 release of Transformers v5 we have got proper, inspectable, debuggable architectures. You define the pipeline explicitly - normalizer, pre‑tokenizer, model (BPE/Unigram/WordPiece), post‑processor, decoder - and then load or train vocab + merges on top, similar to defining a neural net before loading weights. That means you can start from a blank llama tokenizer, feed in your own domain data, and get a custom tokenizer that behaves like LLaMA but speaks “legal”, “medical”, or “logs” fluently. The library also cleans up the class hierarchy and workflow: one main Rust‑backed tokenizers backend instead of parallel slow/fast paths, a clear base class with chat templates and special‑token handling, and a straightforward loop of “instantiate architecture → train on data → push to Hub / reuse.” this removes a ton of subtle bugs around padding, truncation, and BOS/EOS handling, and makes it far easier to reason about why a model saw a particular sequence of IDs. The result is that tokenization stops being an afterthought and becomes a real design lever. Teams that actually understand and customize their tokenizers will quietly win on context length, stability, and domain fit, while everyone else keeps losing quality in the first milliseconds of the pipeline - before a single attention head even wakes up. #tokenization #machinelearning #llm #google #chatgpt #datascience

I spent weeks writing documentation that was supposed to help AI generate better code. Then I realized: I was making it worse. 🤦 Here's what happened 👇 --- I'm building Yieldly — a platform where retail traders can build and test trading strategies without risking real money. Think of it as a "flight simulator" for algorithmic trading: connect your exchange account (read-only), write strategies in Python or use a visual builder, and backtest them against real historical data. As a Solutions Architect, I wanted to build this the right way: 📋 TOGAF methodology for structured documentation 📊 C4 diagrams for clear architecture visualization 📝 Architecture Decision Records for every major choice My ambitious goal: create documentation so well-structured that AI (Claude, GPT) could generate production-quality code from it. This isn't just a side project — it's becoming my Master's thesis at Polish-Japanese Academy of Information Technology in Warsaw. --- So I started documenting everything. Process flows. API contracts. SQL queries. JSON examples. Every edge case. 262 files later, I hit a wall. 🧱 The documentation was: ❌ Hard to maintain — examples got outdated immediately ❌ Confusing for AI — it copied sample IPs and test data as real values ❌ Restrictive for Humans— implied only one "right" way to implement things I started writing actual code, not documentation. --- 💡 THE INSIGHT: AI doesn't need MORE detail. It needs CLEAR hierarchy. What actually matters: 1️⃣ WHAT are we building? → Requirements 2️⃣ WHY this approach? → Architectural Decisions 3️⃣ WHAT'S the exact structure? → Specifications (schemas, APIs) The HOW should be left to the developer — whether human or AI. --- 🔬 MY THESIS RESEARCH QUESTION: How does documentation structure affect AI code generation accuracy and integration error rates? HYPOTHESIS: Layered documentation with explicit "source of truth" hierarchy reduces AI-generated integration errors by 50%+ compared to example-heavy documentation. I'm testing this by: 1. Restructuring my 262 files into a cleaner hierarchy 2. Generating the MVP code using AI 3. Measuring: integration errors, rework cycles, requirement compliance --- 🚀 I'M BUILDING THIS IN PUBLIC. The repository is now live on GitHub. You can explore: → Business requirements and user stories → 32 Architecture Decision Records → Database schemas for 7 microservices → C4 architecture diagrams → And yes, all 262 files (work in progress) 🔗 Link: https://lnkd.in/dsw5ckAi --- I'd love to hear from you: Have you tried using AI for code generation from documentation? What patterns worked? What failed spectacularly? 😅 Drop your experience in the comments — I'm genuinely curious. --- #SoftwareArchitecture #AIAssistedDevelopment #BuildInPublic #AlgorithmicTrading #TOGAF #CloudArchitecture #MasterThesis #Documentation #TechStartup #FinTech