<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Siddharthan TR on Medium]]></title>
        <description><![CDATA[Stories by Siddharthan TR on Medium]]></description>
        <link>https://medium.com/@siddhuwrites?source=rss-4ffbbb54f374------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*k5qzDqM9U38wwtHf</url>
            <title>Stories by Siddharthan TR on Medium</title>
            <link>https://medium.com/@siddhuwrites?source=rss-4ffbbb54f374------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 08:36:27 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@siddhuwrites/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The Day My 3-Year-Old Taught Me What Love and Pain Feel Like Together]]></title>
            <link>https://medium.com/@siddhuwrites/the-day-my-3-year-old-taught-me-what-love-and-pain-feel-like-together-eac19b0cbaf9?source=rss-4ffbbb54f374------2</link>
            <guid isPermaLink="false">https://medium.com/p/eac19b0cbaf9</guid>
            <category><![CDATA[dads]]></category>
            <category><![CDATA[son]]></category>
            <category><![CDATA[cry]]></category>
            <dc:creator><![CDATA[Siddharthan TR]]></dc:creator>
            <pubDate>Tue, 03 Nov 2026 13:50:02 GMT</pubDate>
            <atom:updated>2026-11-03T13:55:24.980Z</atom:updated>
            <content:encoded><![CDATA[<p>This morning, I stood outside my son’s school holding a little boy who did not want to let go.</p><p>On the way, Dheeru asked me, “Appa, will you pick me up at 12.30?” That’s when his school closes.</p><p>I told him gently, “No, Dheeru. I won’t be able to. Appa has office all five days from this week. I’ll drop you in the morning, and Amma will pick you up at 1.15.” She’s a dentist, and her clinic only wraps up at 1.</p><p>He listened. I thought he understood.</p><p>Then the school gate came into view. I asked him to go inside, and he wrapped his arms around my neck and held on tight.</p><p>“I don’t want to go. I want to be with you. Don’t go to office, Appa. Don’t leave me.”</p><p>And then he cried. Not a small cry. The kind that shakes a whole body.</p><p>He has never done this. Not even on his first day of school. He has always walked in like it was the most natural thing in the world. So I wasn’t ready for this.</p><p>I handed him over, and I walked back to the car with my heart left behind at that gate.</p><p>At home, I told my wife what happened. She stayed calm, as she always does. “He’ll be okay. It’s new for him. He’ll adjust.”</p><p>I knew she was right. I still called his teacher to check on him. She told me he had settled in and was playing with another kid. She even sent me a video of him smiling.</p><p>I watched it, relieved. And I still couldn’t shake the feeling.</p><p>Because here is the thing I couldn’t stop thinking about. Since the day we found out we were expecting, I have never been away from him for a full week of office. I worked from home until he turned two. After that, I went in just two days a week. I was always close. Always a few steps away.</p><p>This week, that changed.</p><p>My wife looked at me and asked, “Are you crying?”</p><p>“No,” I said.</p><p>But I was. And when I finally said it out loud, I broke down. “It’s new for him, yes. But it’s new for me too. I’ve never had to leave him like this.”</p><p>The last time I cried was at my grandmother’s funeral on May 11, 2024. Today, I cried again. Different reason, same ache.</p><p>Somewhere in the middle of those tears, I understood something. Love and pain are not opposites. They show up together. The more you love someone, the more it hurts when you have to walk away, even for a good reason.</p><p>He will adjust. Children do. By next week, he’ll probably run in without looking back.</p><p>I’m not sure I’ll adjust as quickly.</p><p>But I wanted to write this down so that years from now, when he’s too big to be carried and too busy to hold on, I can remember the morning my little boy begged me not to go, and how much I wanted to stay.</p><p><em>Dheeru, if you ever read this: I’m always coming back for you. Always.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eac19b0cbaf9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Governance Isn’t the Brake. It’s the Steering Wheel.]]></title>
            <link>https://medium.com/@siddhuwrites/governance-isnt-the-brake-it-s-the-steering-wheel-cc909ded3c2a?source=rss-4ffbbb54f374------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc909ded3c2a</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-governance]]></category>
            <dc:creator><![CDATA[Siddharthan TR]]></dc:creator>
            <pubDate>Fri, 11 Sep 2026 11:57:41 GMT</pubDate>
            <atom:updated>2026-09-11T11:57:41.384Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why “faster” and “safer” stopped being opposites the moment AI agents entered the software delivery lifecycle.</h3><p>There’s a line I hear in almost every engineering org I’ve worked with, in some form or another: “We’d move faster if governance would just get out of the way.”</p><p>It sounds reasonable. It’s also mostly wrong. And the rise of agentic software delivery is making that clearer than ever.</p><p>For years, the assumption was that writing code was the bottleneck in software delivery. So the industry built better IDEs, smarter autocomplete, and coding copilots. And they worked. Developers got faster inside the editor.</p><p>But anyone who has shipped software at scale knows the real drag was never just the typing. It was everything around the code: setting up environments, writing and running tests, managing deployments, triaging incidents, checking quality, and keeping work moving across a dozen disconnected tools. A coding assistant that only lives in the IDE doesn’t touch any of that. Software delivery is much bigger than the IDE.</p><p>That’s the gap the newest generation of AI platforms is trying to close, not by making developers type faster, but by taking on the delivery lifecycle itself: planning a change, generating the code, running the checks, opening the PR, supporting the deployment, watching runtime behavior, and surfacing what needs attention. The idea is simple to say and hard to build: go from intent to production, with humans still in control.</p><p>That last part is the whole argument of this piece.</p><h3>The false trade-off</h3><p>The mental model most orgs still carry is a dial with “speed” on one end and “control” on the other. Push toward speed, you lose control. Push toward control, you lose speed.</p><p>This model made sense when governance meant a human reviewing a document before something got approved. Every checkpoint was a queue, and every queue was latency. Under that model, the trade-off was real.</p><p>But that’s not how delivery works when AI agents are doing the heavy lifting. An agent that plans a change, writes the code, and runs the checks isn’t removing governance from the pipeline, it’s compressing the distance between “here’s what needs to happen” and “here’s the evidence you need to approve it.” The governance doesn’t disappear. It shows up earlier, faster, and in a form a human can actually verify in minutes instead of days.</p><p>The orgs still treating speed and control as a dial to be balanced aren’t protecting themselves. They’re just paying the cost of manual governance without getting the benefit of AI-assisted speed.</p><h3>Where governance actually costs you speed</h3><p>It’s worth being precise about when governance genuinely slows things down, because pretending it never does is its own kind of dishonesty.</p><p><strong>When it’s manual and synchronous.</strong> Anything that requires a human to be in the loop, in real time, before work can proceed, is a queue. Queues have wait times, and the wait time is often longer than the actual work.</p><p><strong>When it’s applied uniformly regardless of risk.</strong> A one-line config fix and a change touching production data shouldn’t go through the same review process. Uniform governance either over-controls the trivial changes or under-controls the risky ones. Usually both, at once.</p><p><strong>When it’s retroactive.</strong> Governance that only checks work after it ships catches problems late, when the cost of fixing them is highest.</p><p><strong>When the reviewer has no real evidence to review.</strong> This is the one that matters most for AI-assisted delivery. If an agent hands a human a pull request with no diff explanation, no record of what checks ran, no rollback path, the human has two bad options: rubber-stamp it, or manually reverse-engineer what the agent did. Neither is governance. Neither is fast.</p><p>Every one of these is fixable. None of them requires removing oversight to fix. They require redesigning what the human is being asked to review, and when.</p><h3>Where governance actually buys you speed</h3><p>This is the part most of these conversations skip: good governance doesn’t just avoid slowing you down. It’s what makes AI-assisted delivery trustworthy enough to actually run at production scale.</p><p><strong>It reduces rework.</strong> A team with clear standards spends less time re-litigating decisions that were supposedly settled months ago. Ambiguity is slow. Enforced clarity is fast, even when it feels like friction in the moment.</p><p><strong>It shrinks the blast radius of mistakes.</strong> When rollback procedures, canary rules, and incident ownership are defined in advance, an incident that could have taken down a service for six hours takes down a fraction of traffic for six minutes. That’s not a compliance win. That’s raw velocity, because the team spends the next morning shipping instead of running a postmortem.</p><p><strong>It’s the only thing that makes agentic delivery usable at all.</strong> An AI agent can generate a working change in minutes. The value of that speed collapses the moment a human can’t tell whether to trust it. This is why the platforms getting real traction in this space are built around explicit approval gates: the engineer sees the diff, the reasoning behind it, the checks that ran, and the rollback path, before anything moves forward. Every meaningful change still goes through human review. The agent handles the delivery-heavy lifting; the engineer keeps the judgment call. That structure isn’t a tax on speed. It’s the reason the speed can be trusted at all. Autonomy without an audit trail isn’t velocity, it’s risk wearing a speed costume. Autonomy with one is the actual unlock.</p><p><strong>It builds the organizational trust that lets you decentralize.</strong> Strong governance at the standards level, what “good” looks like, how risk gets assessed, how decisions get documented, is what lets an organization safely push authority down to individual teams and individual agents. Without that shared baseline, every team, and every agent, has to earn trust from scratch, which means more escalation and more centralized bottlenecks. Good governance is what makes decentralization possible instead of chaotic.</p><h3>What this actually looks like in practice</h3><p>A few patterns show up consistently in teams and platforms that get this right.</p><p><strong>Governance lives in the pipeline, not in a meeting.</strong> Policy-as-code, automated quality and security checks, pre-merge validation. The check still happens. Nobody’s waiting on a human to schedule it.</p><p><strong>Approval gates replace blanket sign-off.</strong> The routine, low-risk work moves through with a lightweight path. The changes that touch production, security, or customer data get real scrutiny, with the reasoning and evidence surfaced clearly enough that scrutiny is fast rather than exhausting.</p><p><strong>The evidence is built for a human to verify quickly, not just to exist.</strong> A diff without context is not an audit trail. A check that ran without a visible result is not a guardrail. The whole point of surfacing “what needs attention” is that a human can act on it in minutes, not spend an afternoon reconstructing what happened.</p><p><strong>Documentation is treated as infrastructure, not an artifact.</strong> The teams, and the agents, that move fastest are working against documentation that’s current and genuinely usable by the next engineer, or the next AI system, that touches the codebase. Documentation debt is functionally identical to technical debt: invisible on today’s velocity chart, expensive on next quarter’s.</p><p><strong>Delivery throughput and governance are measured together, not traded off against each other.</strong> DORA metrics next to audit and control metrics, on the same dashboard, reviewed by the same team. The moment you separate those two conversations, you’re back to treating them as opposites.</p><h3>The real question</h3><p>The question worth asking isn’t “how do we remove oversight so we can move faster.” It’s “where is our oversight still manual and synchronous when it could be automated and evidence-based, and where are we asking humans to approve things without giving them enough to actually judge.”</p><p>Answer that honestly, and most orgs find the bottleneck was never governance itself. It was governance built for a slower, fully-manual era, still running unchanged inside a delivery pipeline that now has AI agents moving at a very different speed.</p><p>Speed without governance isn’t velocity. It’s risk you haven’t priced yet. Governance without speed isn’t safety. It’s an organization quietly losing ground to a competitor who figured out how to do both at once, intent to production, with humans still holding the decisions that matter.</p><p>That’s not a trade-off. That’s the design goal.</p><p><em>If you work in technical documentation, developer tooling, or agentic software delivery and this resonated, I’d love to hear how your team draws this line. Find me on Medium </em><a href="https://medium.com/@siddhuwrites"><em>@siddhuwrites</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc909ded3c2a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Automated Element Quantification in an Enterprise CAD Platform Using Python]]></title>
            <link>https://medium.com/@siddhuwrites/how-i-automated-element-quantification-in-an-enterprise-cad-platform-using-python-b38cc68c773e?source=rss-4ffbbb54f374------2</link>
            <guid isPermaLink="false">https://medium.com/p/b38cc68c773e</guid>
            <dc:creator><![CDATA[Siddharthan TR]]></dc:creator>
            <pubDate>Wed, 02 Sep 2026 06:22:08 GMT</pubDate>
            <atom:updated>2026-09-02T06:22:08.221Z</atom:updated>
            <content:encoded><![CDATA[<h3>When the API you’ve always relied on suddenly stops working, you learn more in one week than in one year of smooth sailing.</h3><p>Every architectural and civil engineering firm faces the same tedious task: opening a floor plan, manually counting every door, window, bathtub, sink, and light fixture, then typing those numbers into a spreadsheet. It’s slow, error-prone, and soul-crushing.</p><p>I was handed exactly this problem. A large DGN-based floor plan with hundreds of elements placed as reusable cell blocks, and a deadline to produce an accurate quantity takeoff. The obvious answer was automation. The not-so-obvious part was that the platform’s scripting API had been quietly gutted in its latest release.</p><p>This is the story of how I solved it — and what I learned about building resilient automation against enterprise software that doesn’t care about your deadlines.</p><h3>The Problem</h3><p>Architectural drawings use cell elements (reusable blocks) to represent real-world objects. A door is a cell named something like DOOR_SINGLE_900. A bathtub might be BATH_TUB_1800. A legend on the drawing shows which cell represents which object.</p><p>The task: scan the entire model, identify every cell, match its name against a legend of keywords, and produce a categorized count.</p><pre>&quot;DOOR_SINGLE_900&quot;  → contains &quot;door&quot;  → Doors<br>&quot;BATH_TUB_1800&quot;    → contains &quot;bath&quot;  → Bathtubs<br>&quot;WIN_CAS_1200&quot;     → contains &quot;win&quot;   → Windows</pre><p>Simple in concept. The challenge was entirely in the execution.</p><h3>The Architecture I Planned</h3><p>The approach was straightforward:</p><pre>─────────────────────────────────────────────┐<br>│  Python Script                              │<br>│                                             │<br>│  1. Connect to the running CAD application  │<br>│  2. Access the active design file &amp; model   │<br>│  3. Scan all elements                       │<br>│  4. Filter for cell-type elements           │<br>│  5. Match cell names against keyword map    │<br>│  6. Aggregate counts                        │<br>│  7. Export CSV + print summary              │<br>└─────────────────────────────────────────────┘</pre><p>I built a keyword-to-category mapping dictionary:</p><pre>LEGEND_MAP = {<br>    &quot;door&quot;:    &quot;Doors&quot;,<br>    &quot;dr&quot;:      &quot;Doors&quot;,<br>    &quot;window&quot;:  &quot;Windows&quot;,<br>    &quot;win&quot;:     &quot;Windows&quot;,<br>    &quot;bathtub&quot;: &quot;Bathtubs&quot;,<br>    &quot;bath&quot;:    &quot;Bathtubs&quot;,<br>    &quot;sink&quot;:    &quot;Sinks&quot;,<br>    &quot;toilet&quot;:  &quot;Toilets&quot;,<br>    &quot;wc&quot;:      &quot;Toilets&quot;,<br>    &quot;shower&quot;:  &quot;Showers&quot;,<br>    &quot;column&quot;:  &quot;Columns&quot;,<br>    &quot;beam&quot;:    &quot;Beams&quot;,<br>    &quot;light&quot;:   &quot;Light Fixtures&quot;,<br>}</pre><p>Classification was a simple substring match:</p><pre>def classify_cell(cell_name: str) -&gt; str:<br>    lower = cell_name.lower()<br>    for keyword, category in LEGEND_MAP.items():<br>        if keyword in lower:<br>            return category<br>    return &quot;Other&quot;</pre><p>The hard part was step 3: actually scanning the elements.</p><h3>Attempt 1: The Legacy COM API</h3><p>The platform has historically exposed a COM/ActiveX interface. Every script, macro, and third-party tool for the past 15 years used it. The documentation was full of examples like this:</p><pre><br>import win32com.client<br><br>app = win32com.client.GetActiveObject(&quot;CADApp.Application&quot;)<br>model = app.ActiveDesignFile.ActiveModelReference<br>criteria = app.CreateElementScanCriteria()<br>criteria.ExcludeAllTypes()<br>criteria.IncludeType(2)  # Cell headers<br>enumerator = model.Scan(criteria)<br><br>while enumerator.MoveNext():<br>    elem = enumerator.Current<br>    cell_name = elem.AsCellElement.Name<br>    # ... process</pre><p>I ran it. It connected successfully. Then it crashed:</p><pre>AttributeError: &lt;unknown&gt;.ActiveModelReference</pre><p>The ActiveModelReference property had moved from the DesignFile object to the Application object. Easy fix — I updated the reference. Then:</p><pre>AttributeError: CADApp.Application.CreateElementScanCriteria</pre><p>The method was gone. Not deprecated with a warning. Not returning empty results. Just… removed from the dispatch interface.</p><p><strong>Lesson 1</strong>: Enterprise software vendors can and will strip legacy APIs without notice in major version updates. Your automation is only as stable as the API contract, and that contract can change overnight.</p><h3>Attempt 2: Selection Set Fallback</h3><p>I pivoted to a workaround: use the application’s key-in command system to select all elements, then read from the selection set.</p><pre>app.Keyin(&quot;select all&quot;)<br>enumerator = design_file.SelectionSet.GetElementEnumerator()</pre><p>Result:</p><pre>AttributeError: CADApp.Application.Keyin</pre><p>The Keyin method was also gone. I tried ProcessKeyin (the newer equivalent) — that worked. But then:</p><pre>AttributeError: &lt;unknown&gt;.SelectionSet</pre><p>SelectionSet was no longer exposed on any object I could find — not the application, not the design file, not the model.</p><p>I built a “shotgun” fallback that tried six different enumeration paths:</p><pre># Try every possible location for SelectionSet<br>for obj in [app, design_file, model]:<br>    if hasattr(obj, &#39;SelectionSet&#39;):<br>        enumerator = obj.SelectionSet.GetElementEnumerator()<br>        break</pre><p>None of them existed. Every single COM-based element enumeration path had been sealed off.</p><p><strong>Lesson 2</strong>: When building automation against enterprise platforms, always have a fallback strategy. But also know when to stop patching a dying API and switch approaches entirely.</p><h3>Attempt 3: The .NET API</h3><p>The platform had been migrating to a .NET-based internal architecture for several releases. The modern API used managed assemblies:</p><ul><li>Platform.DgnAccess — file and model access</li><li>Platform.Elements — element types and iteration</li><li>Platform.Session — application session management</li></ul><p>The correct approach was to use pythonnet (Python for .NET) to call these assemblies directly:</p><pre>import clr<br>clr.AddReference(&quot;Platform.DgnAccess&quot;)<br>clr.AddReference(&quot;Platform.Elements&quot;)<br>clr.AddReference(&quot;Platform.Session&quot;)<br><br>from Platform.Elements import CellElement<br>from Platform.Session import SessionManager</pre><p>I installed pythonnet into the platform&#39;s bundled Python environment:</p><pre>/path/to/platform/python/python.exe -m pip install pythonnet</pre><p>It installed successfully. But when I ran the script:</p><pre>Could not load file or assembly &#39;Platform.Session&#39;<br>or one of its dependencies. The system cannot find the file specified.</pre><p>The assemblies weren’t in the standard search path. I tried adding the installation directory explicitly:</p><pre>sys.path.append(r&quot;C:\Program Files\CADVendor\CADPlatform 2026&quot;)<br>clr.AddReference(r&quot;C:\Program Files\...\Platform.DgnAccess.dll&quot;)</pre><p>The DLLs weren’t in the root installation folder. They were scattered across subdirectories with names like bin\managed, assemblies\core, and other vendor-specific paths.</p><p><strong>Lesson 3</strong>: .NET assembly resolution is a dark art. Just because an assembly is “loaded” in a host process doesn’t mean pythonnet can find it from an external Python process. The host&#39;s assembly resolver and Python&#39;s are completely separate.</p><h3>The Breakthrough: Running Inside the Host Process</h3><p>The key realization came from looking at <em>where</em> my script was located:</p><pre>...\CADPlatform 2026\Configuration\WorkSpaces\...\Macros\legend.py</pre><p>It was inside the platform’s own configuration tree. The platform had a built-in Python manager that executed scripts within its own process space. When running inside the host, all .NET assemblies were already loaded into the AppDomain.</p><p>I didn’t need to call clr.AddReference() at all. I just needed to import directly:</p><pre>import clr  # pythonnet is already available in the host&#39;s Python<br><br># Assemblies are already loaded by the host process<br>from Platform.DgnAccess import DgnModel, DgnFile<br>from Platform.Elements import CellElement<br>from Platform.Session import SessionManager</pre><p>I added a detection mechanism to handle both scenarios:</p><pre>def is_running_inside_host():<br>    &quot;&quot;&quot;Check if script runs inside the CAD platform&#39;s process&quot;&quot;&quot;<br>    script_path = os.path.abspath(__file__)<br>    return &quot;CADPlatform&quot; in script_path or &quot;PlatformPython&quot; in sys.executable<br><br>if is_running_inside_host():<br>    # Assemblies already loaded — import directly<br>    from Platform.Elements import CellElement<br>    from Platform.Session import SessionManager<br>else:<br>    # External execution — must load assemblies manually<br>    # (requires knowing exact DLL paths)<br>    ...</pre><h3>The Final Working Solution</h3><p>Here’s the cleaned-up architecture of the working script:</p><pre>&quot;&quot;&quot;<br>Automated Element Quantification Script<br>Runs inside the host CAD platform&#39;s Python environment<br>&quot;&quot;&quot;<br><br>import os, csv<br>from collections import defaultdict<br>from datetime import datetime<br><br># ── Configuration ──────────────────────────────<br>LEGEND_MAP = {<br>    &quot;door&quot;: &quot;Doors&quot;, &quot;dr&quot;: &quot;Doors&quot;,<br>    &quot;window&quot;: &quot;Windows&quot;, &quot;win&quot;: &quot;Windows&quot;,<br>    &quot;bathtub&quot;: &quot;Bathtubs&quot;, &quot;bath&quot;: &quot;Bathtubs&quot;,<br>    &quot;sink&quot;: &quot;Sinks&quot;, &quot;toilet&quot;: &quot;Toilets&quot;,<br>    &quot;shower&quot;: &quot;Showers&quot;, &quot;column&quot;: &quot;Columns&quot;,<br>    &quot;beam&quot;: &quot;Beams&quot;, &quot;light&quot;: &quot;Light Fixtures&quot;,<br>}<br><br># ── Import platform .NET API ───────────────────<br>import clr<br>from Platform.Elements import CellElement<br>from Platform.Session import SessionManager<br><br># ── Classification ─────────────────────────────<br>def classify(name: str) -&gt; str:<br>    lower = name.lower()<br>    for kw, cat in LEGEND_MAP.items():<br>        if kw in lower:<br>            return cat<br>    return &quot;Other&quot;<br><br># ── Scan &amp; Count ───────────────────────────────<br>def scan():<br>    model = SessionManager.Instance.GetActiveModel()<br>    dgn_file = model.GetDgnFile()<br>    <br>    counts = defaultdict(int)<br>    details = []<br>    unmatched = set()<br>    <br>    for elem in model.GetGraphicElements():<br>        if isinstance(elem, CellElement):<br>            name = elem.Name<br>            cat = classify(name)<br>            counts[cat] += 1<br>            <br>            level = &quot;?&quot;<br>            try:<br>                lvl = dgn_file.GetLevel(elem.LevelId)<br>                if lvl: level = lvl.Name<br>            except: pass<br>            <br>            details.append({<br>                &quot;Cell&quot;: name, &quot;Category&quot;: cat, &quot;Level&quot;: level<br>            })<br>            if cat == &quot;Other&quot;:<br>                unmatched.add(name)<br>    <br>    return counts, details, unmatched<br><br># ── Report ─────────────────────────────────────<br>def main():<br>    counts, details, unmatched = scan()<br>    <br>    print(f&quot;{&#39;Category&#39;:&lt;25} {&#39;Count&#39;:&gt;5}&quot;)<br>    print(&quot;-&quot; * 32)<br>    for cat in sorted(counts):<br>        if cat != &quot;Other&quot;:<br>            print(f&quot;{cat:&lt;25} {counts[cat]:&gt;5}&quot;)<br>    <br>    # Export CSV next to the DGN file<br>    dgn_path = SessionManager.Instance \<br>        .GetActiveModel().GetDgnFile().GetFilePath()<br>    csv_path = dgn_path.rsplit(&#39;.&#39;, 1)[0] + &quot;_report.csv&quot;<br>    <br>    with open(csv_path, &quot;w&quot;, newline=&quot;&quot;) as f:<br>        w = csv.DictWriter(f, fieldnames=[&quot;Cell&quot;,&quot;Category&quot;,&quot;Level&quot;])<br>        w.writeheader()<br>        w.writerows(details)<br>    <br>    print(f&quot;\nSaved → {csv_path}&quot;)<br><br>if __name__ == &quot;__main__&quot;:<br>    main()</pre><p>Sample output:</p><pre>Category                    Count<br>--------------------------------<br>Bathtubs                        4<br>Beams                          12<br>Columns                        24<br>Doors                          27<br>Light Fixtures                 42<br>Showers                         4<br>Sinks                           8<br>Toilets                         6<br>Windows                        18<br><br>Saved → C:\Projects\Floorplan_report.csv</pre><h3>What I Learned</h3><h3>1. Enterprise APIs are living organisms</h3><p>They evolve, shed limbs, and grow new ones. The COM interface that powered 15 years of automation was quietly retired. The documentation hadn’t caught up. The only way to discover what worked was to try, fail, read the error, and adapt.</p><h3>2. Process context matters more than you think</h3><p>The same Python code behaves completely differently depending on whether it runs inside the host application’s process or as an external script. Inside the process, you inherit the host’s loaded assemblies, memory space, and security context. Outside, you’re a stranger knocking on a locked door.</p><h3>3. Build detection, not assumptions</h3><p>The final script detects its execution context and adapts. This single pattern saved the project:</p><pre>if running_inside_host():<br>    # Use pre-loaded assemblies<br>else:<br>    # Load manually or fail gracefully</pre><h3>4. The “shotgun fallback” pattern is real engineering</h3><p>Trying six different API paths in sequence isn’t elegant, but it’s honest. Enterprise software is inconsistent across versions, editions, and configurations. Defensive enumeration of possible API surfaces is a legitimate strategy.</p><h3>5. The boring solution is usually the right one</h3><p>A dictionary of keyword-to-category mappings with substring matching isn’t glamorous. But it’s readable, maintainable, and extensible. Adding a new legend item is one line. No regex. No ML. Just a dictionary.</p><h3>The Impact</h3><p>What used to take 2–3 hours of manual counting and cross-referencing now runs in under 10 seconds. The CSV output feeds directly into the quantity surveying workflow. Unmatched cell names are flagged for review, catching naming inconsistencies in the design file that would have been missed manually.</p><p>More importantly, the script is version-resilient. By detecting its execution context and using the modern .NET API, it will continue working as the platform evolves — at least until the next API revolution.</p><p><em>If you’re building automation against enterprise design platforms, I’d love to hear about your API war stories. The scars we collect from deprecated interfaces are a badge of honor in this line of work.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b38cc68c773e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What I Learned Prototyping an AI Agent for a Real (and Messy) Enterprise Problem]]></title>
            <link>https://medium.com/@siddhuwrites/what-i-learned-prototyping-an-ai-agent-for-a-real-and-messy-enterprise-problem-99ff36bc8098?source=rss-4ffbbb54f374------2</link>
            <guid isPermaLink="false">https://medium.com/p/99ff36bc8098</guid>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[enterprise-software]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Siddharthan TR]]></dc:creator>
            <pubDate>Thu, 27 Aug 2026 11:33:21 GMT</pubDate>
            <atom:updated>2026-08-27T11:33:21.649Z</atom:updated>
            <content:encoded><![CDATA[<p>A few weeks ago, a senior colleague on our presales team reached out with a question: <em>“Do you know anything about building AI agents that can plug into enterprise software?”</em></p><p>I do CAD documentation for a living, not agent architecture. But I said yes anyway — partly out of curiosity, partly because I could tell this was a chance to stretch beyond my usual lane. What followed was one of the more useful crash courses I’ve had this year, not because I built something production-ready, but because of everything I had to think through <em>before</em> writing a line of code.</p><p>This is that story — the idea, the honest problems with it, and the small, testable pieces I actually got working.</p><h3>The Problem, In Plain Terms</h3><p>Our company builds engineering design software used heavily in infrastructure and utilities work. A huge share of new clients arrive already using a <em>different</em>, more widely adopted CAD platform, and every migration project hits the same two friction points:</p><p><strong>1. Organizational structure doesn’t translate cleanly.</strong> The source platform organizes a drawing one way; our platform organizes the same idea differently — similar concept, different rules, different metadata. Today, someone manually re-matches the entire structure of a drawing by hand, on every single project.</p><p><strong>2. Visual attributes don’t translate either.</strong> Each platform keeps its own private table of colors, and a colour numbered a certain way in one system isn’t the same colour in the other. Right now, someone matches these by eye, one at a time, hoping they don’t miss an edge case.</p><p>Neither problem is exotic. They’re the unglamorous, repetitive kind of friction that eats hours on every project and never makes it into a case study — which is exactly why an AI agent seemed worth exploring. Not a flashy demo. A genuinely tedious task, done today by a human, that a well-scoped agent might do faster with a person still checking the output.</p><h3>The Idea, Stripped of Jargon</h3><p>Here’s the mental model I landed on: think of an AI agent as a smart assistant with a specific, narrow job. On its own, that assistant can talk about our software in general terms, but it can’t actually open a file and read what’s inside it.</p><p>To fix that, you build a small piece of connective software — a translator, essentially — that lets the agent ask specific questions about a file (“what’s in this drawing’s structure list?” or “what colors does it use?”) and get real answers back. The agent then uses those answers to propose something useful: <em>here’s a suggested mapping, here’s my confidence level, please review before this goes anywhere real.</em></p><p>That last part — a human always reviews before anything is applied — turned out to be the single most important design decision in the entire idea. More on why below.</p><h3>Being My Own Harshest Critic</h3><p>Before I let myself get excited about the idea, I made myself write out every way it could fail. A few of these stung a little, because they meant walking back some of my own initial enthusiasm:</p><ul><li><strong>The automation layer isn’t a simple, scalable service.</strong> Enterprise CAD automation often needs a live, licensed session of the actual software running — not a stateless cloud function you spin up and forget. That’s a real infrastructure cost, not a one-time build.</li><li><strong>Confident-looking wrong answers are worse than slow, careful ones.</strong> A human eye-matching colours is tedious, but it forces scrutiny. An agent that looks authoritative and is quietly wrong is more dangerous, because people stop double-checking. Any version of this needs mandatory human sign-off baked into the design, not offered as an afterthought.</li><li><strong>Some clients operate under strict, contractually mandated standards.</strong> For regulated industries, the exact structure and naming inside a drawing is often dictated by the client’s own compliance requirements — not something an AI should be guessing at, however cleverly.</li><li><strong>Client data governance isn’t optional.</strong> The moment a real client file passes through a third-party AI platform, it’s left your controlled environment. That needs explicit written sign-off, every time — not an assumption that it’s fine because the demo looked good.</li><li><strong>There was no formal charter for any of this.</strong> No budget, no timeline, no named owner. That’s fine for an exploratory prototype done in spare hours — but it’s a real limit on how far the idea should go before someone senior actually commits to it.</li></ul><p>I’d rather list these plainly in a portfolio post than pretend the idea arrived fully formed. Good engineering — and honestly, good technical writing — is as much about naming the risks clearly as it is about building the thing.</p><h3>What I Actually Built (and What I Didn’t)</h3><p>I split the work into two honest categories: things I could build and test myself with zero special access, and things that genuinely need a licensed environment I don’t have on my own machine.</p><p><strong>What’s real and tested:</strong> the matching logic. For the structure-mapping problem, I wrote a small fuzzy-matching function that normalizes names (so formatting differences like dashes versus underscores don’t trip it up) and scores how closely an incoming name matches each existing option — flagging anything below a confidence threshold for human review instead of guessing. For the colour problem, I wrote a straightforward distance calculation that compares colours numerically and picks the closest match, again flagging anything too far off to trust blindly.</p><p>I ran both of these against sample data before touching anything else, specifically so I wasn’t fooling myself about whether the core logic actually worked. It did — cleanly, and in a way I could verify line by line.</p><p><strong>What’s honestly a stub:</strong> the part that opens real files inside the actual CAD software. That requires a licensed installation and vendor-specific automation APIs I don’t have personal access to outside of a work environment, so I wrote that part to show the <em>shape</em> of what’s needed — clearly labeled as something a developer would need to verify against the real SDK documentation, not something to trust blindly from a first pass.</p><p>I think that distinction — being explicit about what’s proven versus what’s a well-informed placeholder — is more valuable to show in a portfolio than a polished demo that quietly glosses over the hard 20%.</p><h3>The Actual Takeaway</h3><p>I’m not an engineer by training, and I’m not going to pretend this prototype is close to something a client could rely on. But going through this end-to-end — translating a vague, exciting pitch into a real technical breakdown, stress-testing my own idea before anyone else could, and being honest about where the prototype stops and real infrastructure work begins — was a genuinely useful exercise in the kind of systems thinking that technical writers rarely get invited into, and probably should be.</p><p>If you’re a technical writer wondering whether any of this is “your lane”: I’d say build the muscle anyway. Not to become an engineer, but because the questions worth asking before a project starts — what could go wrong, who reviews the output, what happens to sensitive data — are exactly the questions clear writing and clear thinking are built for.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=99ff36bc8098" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Video Script: AI Agents in the Documentation Workflow (90-Second Explainer)]]></title>
            <link>https://medium.com/@siddhuwrites/video-script-ai-agents-in-the-documentation-workflow-90-second-explainer-3a9c04ba1625?source=rss-4ffbbb54f374------2</link>
            <guid isPermaLink="false">https://medium.com/p/3a9c04ba1625</guid>
            <category><![CDATA[documentation]]></category>
            <category><![CDATA[ai-tools]]></category>
            <category><![CDATA[accessibility]]></category>
            <category><![CDATA[technical-writing]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Siddharthan TR]]></dc:creator>
            <pubDate>Wed, 26 Aug 2026 10:32:11 GMT</pubDate>
            <atom:updated>2026-08-26T10:32:11.975Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A companion piece to</em> <a href="https://medium.com/@siddhuwrites/building-ai-agents-into-the-documentation-workflow-a-practical-case-study-in-alt-text-and-30a8772a22c9"><em>Building AI Agents Into the Documentation Workflow</em></a></p><p>I turned my case study on the two Copilot agents I built for ALT-text generation and WCAG accessibility review into a short explainer script. Sharing it here as a look at how the same technical story gets reshaped for a different format and a different attention span.</p><p>VisualVoiceoverScreen recording of a documentation page with a screenshot needing ALT-textEvery screenshot in a technical doc needs ALT-text. Every page needs to meet accessibility standards. At scale, that’s hours of repetitive review work every single release.Cut to a simple diagram: “Copilot Agent 1: ALT-Text” and “Copilot Agent 2: WCAG Review”So I built two AI agents into our documentation workflow, using nothing but prompt engineering inside tools we already had.Split screen: image on left, AI-drafted ALT-text appearing on rightThe first drafts ALT-text automatically, focused on function, not just appearance. If an image is too complex to describe in one line, it says so, instead of guessing.Documentation page with flagged issues highlightedThe second reviews pages for WCAG compliance: heading structure, contrast, link text. It flags problems. It doesn’t fix them silently. A human always makes the final call.Simple before/after stat card: “~25% faster review time”The result: about 25% faster accessibility review, and more consistent error-catching than manual review alone.Text on screen: “The lesson? Scope AI narrowly. Let it flag what it doesn’t know.”The real lesson wasn’t speed. It was this: AI becomes trustworthy the moment you let it admit what it doesn’t know.End card with Medium link / nameFull case study linked below.</p><p><strong>Runtime:</strong> ~85–90 seconds at a natural pace.</p><p><em>Siddharthan T R is a Senior Technical Writer with 7+ years of experience in developer-facing and end-user documentation for enterprise software.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3a9c04ba1625" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building AI Agents Into the Documentation Workflow: A Practical Case Study in ALT-Text and…]]></title>
            <link>https://medium.com/@siddhuwrites/building-ai-agents-into-the-documentation-workflow-a-practical-case-study-in-alt-text-and-30a8772a22c9?source=rss-4ffbbb54f374------2</link>
            <guid isPermaLink="false">https://medium.com/p/30a8772a22c9</guid>
            <category><![CDATA[technical-writing]]></category>
            <category><![CDATA[review]]></category>
            <category><![CDATA[ada]]></category>
            <category><![CDATA[co-pilot]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Siddharthan TR]]></dc:creator>
            <pubDate>Wed, 26 Aug 2026 10:04:23 GMT</pubDate>
            <atom:updated>2026-08-26T10:04:23.533Z</atom:updated>
            <content:encoded><![CDATA[<h3>Building AI Agents Into the Documentation Workflow: A Practical Case Study in ALT-Text and Accessibility Review</h3><h3>The Problem: Accessibility Compliance Doesn’t Scale With Headcount</h3><p>Every screenshot, diagram, and UI element in a piece of technical documentation needs an ALT-text description. Every page needs to meet WCAG standards for contrast, structure, and semantic markup. These aren’t optional — for enterprise software, they’re often a legal and contractual requirement.</p><p>They’re also, frankly, tedious to do well at scale.</p><p>On a documentation team supporting a large, actively developed enterprise product, the volume of visual content grows every release. Screenshots get updated. New diagrams get added. Old ALT-text goes stale the moment the UI changes underneath it. Manually writing and reviewing ALT-text for every image — then separately auditing pages for WCAG compliance — was consuming a meaningful share of review time that could otherwise go toward actually improving content quality.</p><p>The obvious answer was “hire more reviewers.” The realistic answer, given most documentation teams’ headcount, was: find a way to make the existing team faster without cutting corners on compliance.</p><p>That’s the problem I set out to solve using Microsoft Copilot — not as a novelty, but as an actual production tool embedded in our review workflow.</p><h3>Why Prompt Engineering, Not Custom Development</h3><p>I want to be upfront about the approach, because I think it’s the more broadly useful lesson here: I didn’t build custom models or write integration code. I built two purpose-specific agents using structured prompt templates inside our existing Copilot environment.</p><p>This was a deliberate choice, for a few reasons:</p><ul><li><strong>Speed to value.</strong> A custom-built pipeline would have taken weeks of engineering time and approval cycles. Prompt-based agents could be built, tested, and iterated on in days, using tools already licensed and approved for the team.</li><li><strong>Maintainability by non-engineers.</strong> Anyone on the documentation team could read, understand, and modify a prompt template. That’s not true of a custom script or model fine-tune. For a small team, this matters more than raw capability.</li><li><strong>Lower risk surface.</strong> No new data pipelines, no new access requests, no new attack surface. The agents operate entirely within our existing, already-approved AI tooling.</li></ul><p>The trade-off is real: prompt-based agents are less powerful and less consistent than a purpose-built system. But for this problem, “good enough, fast, and maintainable” beat “perfect, slow, and fragile.”</p><h3>Agent One: ALT-Text Generation</h3><p>The first agent’s job was straightforward on paper and surprisingly nuanced in practice: given a screenshot or diagram and its surrounding context, draft ALT-text that’s accurate, concise, and actually useful to a screen-reader user — not just descriptive for description’s sake.</p><p>The prompt template I built does three things before generating a suggestion:</p><ol><li><strong>Anchors on function, not appearance.</strong> A bad ALT-text describes what a button <em>looks like</em>. A good one describes what it <em>does</em>. The template explicitly instructs the agent to prioritize functional description over visual description, and to only mention visual details when they’re load-bearing for understanding (e.g., a warning icon’s color).</li><li><strong>Pulls surrounding text as context.</strong> The agent is given the paragraph before and after the image, so the ALT-text doesn’t redundantly repeat what the surrounding prose already says — a common failure mode when ALT-text is written in isolation.</li><li><strong>Flags its own uncertainty.</strong> If the image contains dense information (a complex diagram, a data table screenshot) that can’t be meaningfully compressed into ALT-text alone, the agent is instructed to say so explicitly and suggest a long-description alternative, rather than silently producing a paragraph-length ALT-text that violates best practice.</li></ol><p>That third point turned out to be the most important design decision in the whole project. Early versions of the prompt happily generated verbose ALT-text for complex diagrams because that felt “more complete.” Making the agent flag its own limits, instead of pretending confidence it didn’t have, is what made the output trustworthy enough to actually rely on.</p><h3>Agent Two: WCAG Compliance Review</h3><p>The second agent works differently — it’s a reviewer, not a drafter. Given a documentation page, it checks against a defined set of common WCAG failure points: heading structure and hierarchy, color contrast flags, table markup for screen readers, and link text that makes sense out of context (“click here” being the classic offender).</p><p>This agent is deliberately conservative. It’s instructed to flag <em>candidates</em> for review, not make unilateral fixes — every flag still goes to a human for judgment. That was a non-negotiable design constraint from the start: accessibility compliance is not a place to let an AI system make silent, unreviewed changes. The agent’s job is to make the reviewer faster at finding problems, not to replace the reviewer’s judgment about what’s actually a problem.</p><h3>What Changed, and What Didn’t</h3><p>After rolling both agents into the standard documentation review workflow, review time for accessibility passes dropped by roughly 20–30%. Just as importantly, the <em>type</em> of errors caught shifted. Both agents caught roughly equal volumes of two different failure categories — missing or inconsistent ALT-text on one side, and structural/contrast WCAG issues on the other — meaning the tooling wasn’t just faster, it was catching a broader, more consistent net of issues than manual spot-checking alone typically caught.</p><p>What didn’t change: final accountability. Every ALT-text suggestion and every compliance flag still goes through human review before it ships. The agents accelerate the first pass; they don’t own the outcome. That distinction matters both practically (AI-generated ALT-text can be confidently wrong) and organizationally — teams trust a new tool faster when its role in the workflow is honestly scoped from day one.</p><h3>The Broader Lesson</h3><p>The most transferable part of this project isn’t the specific prompts — it’s the pattern: <strong>identify a narrow, well-defined, high-volume task; give the AI tool a tightly scoped job with explicit uncertainty-flagging built in; keep a human owning the final call.</strong></p><p>That pattern generalizes well beyond accessibility review. Documentation teams sit on a lot of exactly this kind of repetitive, judgment-light, volume-heavy work — and the gap between “AI as a novelty” and “AI as a reliable teammate” almost always comes down to how honestly the tool is allowed to express what it doesn’t know.</p><p>Siddharthan T R is a Senior Technical Writer with 7+ years of experience in developer-facing and end-user documentation for enterprise software. He currently leads documentation for Bentley Systems’ SUPERLOAD product and serves as an internal AI Champion, running knowledge-sharing sessions on AI-assisted documentation workflows.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=30a8772a22c9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>