First Horizon Bank Cuts Enterprise Architecture Draft Times With AI
Ai4
Combining deterministic Python scripts with large language models collapses multi-week architectural discovery cycles into 45-minute workflows without compromising governance.
## Background
Published on YouTube by the Ai4 channel on August 21, 2026, this presentation features Kevin Kohut, VP of Enterprise Architecture at First Horizon Bank. According to the page description, the session demonstrates in real time how AI workflows can transform discovery meeting transcripts into initial Enterprise Architecture (EA) documentation and sequence diagrams in hours rather than weeks.
## TL;DR
Kevin Kohut outlines First Horizon Bank's strategy for accelerating manual enterprise architecture processes by treating EA artifacts as code. The approach strategically balances deterministic programming (such as using Python for complex JSON/ADF parsing) with probabilistic LLM capabilities designed to synthesize unstructured discovery data, meeting transcripts, and vendor documents. By incorporating human-in-the-loop checkpoints at critical governance gates, the bank auto-generates Mermaid sequence diagrams and initial Application Solution Design (ASD) documentation, drastically shortening a typical 2-to-3-week discovery and drafting cycle down to roughly 45 minutes.
## Atmosphere & style
The presentation carries a pragmatic, industry-grounded, and highly authoritative tone aimed at technical leaders and enterprise architects. Kohut speaks from direct experience, blending structured design philosophy with empathetic reflections on the notorious friction of traditional Architecture Review Boards. The narrative feels practical and solution-oriented, focusing on real-world efficiency gains and architectural rigor rather than ungrounded AI hype.
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=r08lR0crgJ8&t=4s) Traditional Enterprise Architecture (EA) processes are highly manual, taking at least two weeks to create initial drafts and additional days for final documentation.
- [00:04](https://www.youtube.com/watch?v=r08lR0crgJ8&t=4s) Manual EA workflows suffer from complexity and inconsistency when managing interacting systems across complex Confluence spaces and templates.
- [01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) Applying AI to enterprise architecture focuses on process acceleration for governance and artifacts, not writing application code or 'vibe coding.'
- [01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) A fundamental design philosophy for AI workflows is distinguishing between when to use probabilistic models versus deterministic logic.
- [01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) Large Language Models (LLMs) excel at synthesizing unstructured, disparate data like meeting transcripts, emails, and vendor documentation into draft documents.
- [01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) Fixed data structures and strict algorithmic tasks should be handled programmatically using traditional code to avoid schema errors and reduce token costs.
- [01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) Organizations should audit their existing manual processes to identify and target the biggest time bottlenecks before introducing automation.
- [01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) AI workflows in enterprise architecture necessitate 'human-in-the-loop' checkpoints, requiring architect approval at key decision gates.
- [03:10](https://www.youtube.com/watch?v=r08lR0crgJ8&t=190s) Python is superior to LLMs for parsing complex, deeply nested JSON structures like Atlassian Document Format (ADF), where LLMs frequently lose track of syntax.
- [03:10](https://www.youtube.com/watch?v=r08lR0crgJ8&t=190s) Generating architecture diagrams and narrative artifacts carries a low security risk profile because it does not expose or interact with live customer data.
- [03:10](https://www.youtube.com/watch?v=r08lR0crgJ8&t=190s) The AI workflows parse multi-source project inputs from designated folders, maintain state, and automatically generate Mermaid sequence diagrams.
- [03:10](https://www.youtube.com/watch?v=r08lR0crgJ8&t=190s) By implementing these AI workflows, First Horizon Bank collapsed a traditional 2-to-3-week discovery and design cycle into approximately 45 minutes.
## Detailed walkthrough
Here is a detailed, faithful walkthrough of the transcript:
[00:04](https://www.youtube.com/watch?v=r08lR0crgJ8&t=4s) Accelerating Enterprise Architecture at First Horizon Bank
Kevin Kohut wears two primary hats at First Horizon Bank: his day job as Vice President of Enterprise Architecture supporting a commercial banking portfolio, and his role leading internal AI initiatives specifically focused on accelerating the enterprise architecture (EA) process. He sets the stage by acknowledging how familiar—and painful—Architecture Review Board (ARB) reviews are for anyone working in enterprise IT. Historically, First Horizon built a thorough process over several years, but doing it manually is remarkably slow:
* Gathering information and creating an initial draft document takes **at least two weeks**.
* Iterating through discovery and analysis (D&A) meetings requires continuously updating documentation.
* Assembling the final Application Solution Design (ASD) and ARB presentation slides demands **several additional hours, if not days**, before finally seeking approval to move to the next phase.
The manual process is complicated, messy, and inconsistent. Teams juggle numerous interacting systems across complex Confluence spaces and templates, making it difficult to follow procedures consistently or ensure everything was performed correctly.
[01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) Architectural Principles: Deterministic vs. Probabilistic Automation
To address these pain points, Kohut's team identified critical success factors for using AI beyond conventional software engineering. Clarifying that this initiative is not about "vibe coding" or writing application code, Kohut notes that even Y Combinator startups are now raising funding to tackle this exact problem—a realization he had right before the talk when speaking with a Y Combinator founder.
Kohut outlines a fundamental design philosophy for building AI workflows in EA:
* **Know when to use probabilistic vs. deterministic logic:** Large Language Models (LLMs) excel at sifting through disparate, unstructured content (transcripts, emails, vendor docs) to make sense of information. However, algorithmic tasks should remain programmatic.
* **Use code for fixed structures:** Python handles nested data structures and fixed schemas far better than LLMs. For instance, Atlassian Document Format (ADF) inside Confluence uses deeply nested, complex JSON schemas that cause LLMs to lose track of curly braces. Python handles ADF deterministically without failing and costs zero tokens.
* **Target manual bottlenecks first:** Always audit existing manual processes to locate the biggest time drains before adding automation.
* **Keep humans in the loop at critical junctions:** The automated workflows are designed to pause at key decision points, requiring approval from an Enterprise Architect before proceeding. Because architecture diagrams and narrative artifacts do not expose live customer data, the### Accelerating Enterprise Architecture through AI Workflows
Kevin Kohut introduces his dual role at First Horizon Bank: his primary "day job" providing enterprise architecture (EA) support for a commercial banking portfolio, and his secondary "hat" heading up AI initiatives designed specifically to accelerate the enterprise architecture process itself. He addresses the room directly, noting that most attendees have likely participated in Architecture Review Board (ARB) reviews. Historically, First Horizon's manual EA process required at least two weeks just to produce an initial draft. EAs then had to spend weeks iterating through discovery and analysis (D&A) meetings, culminating in hours or days spent assembling the final Application Solution Design (ASD) document and ARB presentation deck to secure formal approval for the next project phase.
Kohut emphasizes that manual EA work is complicated, time-consuming, and notoriously hard to keep consistent across fragmented Confluence spaces and interacting systems. Rather than focusing on common AI applications like "vibe coding," his initiative treats the enterprise architecture process itself as code. He highlights a recent interaction with a Y Combinator startup CEO doing similar work, validating the industry demand. The core principle of his architecture design is knowing when to use deterministic tools versus probabilistic AI models: LLMs excel at digesting unstructured, disparate discovery data to draft documents against internal templates, but strict algorithmic tasks should be offloaded to standard scripts to save time and token costs.
* Manual EA baseline: 2+ weeks to create an initial draft; significant additional time for discovery iteration, ASD drafting, and ARB deck creation.
* Deterministic logic vs. LLMs: Use traditional code for fixed, repeatable logic; use LLMs for unstructured data synthesis.
* Non-coding AI scope: Process acceleration for governance, sequence diagrams, and EA artifacts rather than application code generation.
```
+-----------------------------------------------------------------+
| Traditional Manual EA Flow |
| [ Discovery Meetings ] ---> [ Manual Confluence/Diagram Drafts ]|
| (Takes 2+ Weeks) (Inconsistent, High Effort) |
+-----------------------------------------------------------------+
|
v
+-----------------------------------------------------------------+
| AI-Accelerated EA Flow |
| [ Raw Meeting Transcripts ] -> [ AI Workflow Processing ] |
| (Unstructured Inbox) (45-Min ASD Draft + Mermaid) |
+-----------------------------------------------------------------+
```
[03:10](https://www.youtube.com/watch?v=r08lR0crgJ8&t=190s) Deterministic Python vs. Probabilistic Models and Human-in-the-Loop Governance
Highlighting why deterministic programming remains crucial, Kohut explains that he relies on Python (along with some Node.js) for structured data manipulation. For example, Python effortlessly parses deeply nested JSON schemas, whereas LLMs frequently struggle with structural precision—such as tracking nested curly braces in Atlassian Document Format (ADF) JSON. Running deterministic operations via Python scripts rather than LLM prompts also drastically reduces API token consumption. He advises teams to map out manual workflows first and target the longest manual bottlenecks before introducing automation.
Kohut outlines the necessity of placing "human-in-the-loop" checkpoints at critical decision gates. Because EA workflows handle architecture designs, narratives, and diagrams rather than live customer data, the security risk profile is low; however, human validation remains vital before committing changes to official repositories. Kohut clarifies a common misunderstanding among conference vendors, who often assume his project builds live autonomous agents interacting directly with production databases. Instead, his AI workflows parse project inputs (meeting transcripts, vendor docs, emails) deposited into a designated project folder, maintain state across iterations, auto-generate Mermaid sequence diagrams, and collapse a 2-to-3-week discovery cycle into approximately 45 minutes.
* Atlassian Document Format (ADF): Complex JSON structure best parsed algorithmically with Python to avoid LLM schema failures.
* Workflow execution time
## Notable quotes
> [00:04](https://www.youtube.com/watch?v=r08lR0crgJ8&t=4s) Gathering information and creating an initial draft document takes at least two weeks. — Kevin Kohut
> [00:04](https://www.youtube.com/watch?v=r08lR0crgJ8&t=4s) Iterating through discovery and analysis (D&A) meetings requires continuously updating documentation. — Kevin Kohut
> [00:04](https://www.youtube.com/watch?v=r08lR0crgJ8&t=4s) Assembling the final Application Solution Design (ASD) and ARB presentation slides demands several additional hours, if not days, before finally seeking approval to move to the next phase. — Kevin Kohut
> [00:04](https://www.youtube.com/watch?v=r08lR0crgJ8&t=4s) The manual process is complicated, messy, and inconsistent. — Kevin Kohut
> [01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) Know when to use probabilistic vs. deterministic logic — Kevin Kohut
> [01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) Large Language Models (LLMs) excel at sifting through disparate, unstructured content (transcripts, emails, vendor docs) to make sense of information. However, algorithmic tasks should remain programmatic. — Kevin Kohut
> [01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) Use code for fixed structures — Kevin Kohut
> [01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) Python handles nested data structures and fixed schemas far better than LLMs. — Kevin Kohut
> [01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) Target manual bottlenecks first — Kevin Kohut
> [01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) Keep humans in the loop at critical junctions — Kevin Kohut
> [01:37](https://www.youtube.com/watch?v=r08lR0crgJ8&t=97s) The automated workflows are designed to pause at key decision points, requiring approval from an Enterprise Architect before proceeding. — Kevin Kohut
> [03:10](https://www.youtube.com/watch?v=r08lR0crgJ8&t=190s) Running deterministic operations via Python scripts rather than LLM prompts also drastically reduces API token consumption. — Kevin Kohut
## Mentioned
Kevin Kohut, First Horizon Bank, Architecture Review Board, Confluence, Y Combinator, Atlassian Document Format, Python, Node.js, Mermaid
## Video description
Kevin Kohut - VP, Enterprise Architecture, First Horizon Bank
How we used AI workflows to create versioned Enterprise Architecture assets in hours instead of weeks.
Enterprise Architecture projects involve lots of discovery and analysis followed by manually creating sequence diagrams, architecture designs, and relevant documentation. In this session we will show, in real time, taking a D&A meeting transcript and create initial EA documentation and sequence diagrams,
Whether you are an Enterprise Architect, Product Owner, Business Analyst, or any other stakeholder in a product team you will discover how AI can help accelerate your own projects.
First Horizon Bank利用AI大幅缩减企业架构起草耗时
结合确定性Python脚本与大语言模型，在不削弱治理的前提下，将数周的架构调研周期缩短至45分钟的工作流。
Kevin Kohut概述了First Horizon Bank通过将企业架构（EA）产物视为代码来加速人工EA流程的战略。该方法战略性地平衡了确定性编程（例如使用Python进行复杂的JSON/ADF解析）与用于综合非结构化调研数据、会议纪要和供应商文档的概率性大语言模型（LLM）能力。通过在关键治理关口设立人机协同（human-in-the-loop）检查点，该银行可自动生成Mermaid时序图和初始应用解决方案设计（ASD）文档，将通常需要2到3周的调研与起草周期大幅缩短至约45分钟。
传统的企业架构（EA）流程高度依赖人工，生成初稿至少需要两周时间，完成最终文档还需要额外数天。 (0:04)
在跨越复杂的Confluence空间和模板管理交互系统时，人工EA工作流容易面临复杂且不一致的问题。 (0:04)
将AI应用于企业架构的重点在于加速治理和产物的处理流程，而非编写应用程序代码或进行“氛围编码”（vibe coding）。 (1:37)
AI工作流的基本设计理念之一，在于区分何时使用概率模型与何时使用确定性逻辑。 (1:37)
大语言模型（LLM）擅长将会议纪要、电子邮件和供应商文档等非结构化的零散数据综合提炼为草案文档。 (1:37)
Reading summary
Kevin Kohut, Vice President of Enterprise Architecture at First Horizon Bank, outlines an approach to accelerate architecture governance by pairing deterministic scripts for structured data with large language models for unstructured synthesis.
Inefficiencies in Traditional Enterprise Architecture (0:04)
Enterprise Architecture Review Board (ARB) preparation has historically imposed heavy administrative overhead. At First Horizon Bank, producing an initial draft typically required at least two weeks of manual effort, followed by iterative discovery and analysis meetings. Finalizing the Application Solution Design (ASD) and assembling presentation decks demanded additional hours or days, complicated by inconsistent documentation practices across complex Confluence spaces.
Separating Deterministic Code from Probabilistic Models (1:37)
Kohut argues that enterprise architecture automation must clearly distinguish between programmatic logic and probabilistic language generation. While large language models excel at synthesizing unstructured inputs like emails, transcripts, and vendor documents, they struggle with precise syntax such as nested curly braces in Atlassian Document Format (ADF) JSON. First Horizon uses Python and Node.js for fixed schemas and structural tasks, which eliminates formatting failures and avoids unnecessary API token costs.
Automated Artifact Generation with Human Oversight (3:10)
The bank's automated workflow ingests project inputs from designated folders, tracks state across iterations, and drafts documentation alongside Mermaid sequence diagrams, reducing discovery and drafting cycles from two to three weeks down to roughly 45 minutes.
Kohut clarifies that this framework does not rely on autonomous agents modifying production databases. Instead, it mandates human-in-the-loop checkpoints where an enterprise architect must review and approve artifacts before committing them to formal repositories. He adds that the process maintains a low security risk profile because architectural narratives and diagrams do not expose live customer data.
Kohut demonstrates that targeted automation can drastically accelerate architecture documentation, though ultimate accountability remains tied to human-in-the-loop validation before design artifacts reach formal review boards.
## Background
本内容由频道 Ai4 于 2026 年 8 月 21 日发布在 YouTube 平台上。视频记录了 First Horizon 银行企业架构副总裁 Kevin Kohut 的演讲，内容主要介绍该行如何利用 AI 工作流将原本需要耗费数周的企业架构设计与文档编制流程压缩至数小时内完成。
## TL;DR
Kevin Kohut 分享了 First Horizon 银行将企业架构流程“代码化”（Enterprise Architecture as Code）的创新实践。团队巧妙区分了 Python 确定性算法（处理复杂 ADF JSON 与 API 调用）与 AI 概率性推理（处理非结构化信息与图表生成）的职责边界，并结合 Atlassian MCP 构建了自动化摄取流水线。通过扫描非结构化会议纪要和邮件，系统能自动生成 Jira Epic、Confluence 架构文档及 Mermaid 时序图，将 2 至 3 周的人工作业缩短至 45 分钟。Kevin 强调，AI 的目的在于消除繁琐的机械性文书工作，真正的架构决策权与核心价值仍牢牢掌握在架构师手中。
## Atmosphere & style
整场演讲务实、生动且极具技术洞察力，演讲者以幽默风趣的口吻分享了银行前线探索的真实经历与实操插曲。现场展示未剪辑的 Agent 操作录屏，呈现了真实的技术碰撞与人机协同细节。在会议傍晚的疲惫时刻，讲者充满激情的分享不仅驱散了沉闷，更让观众真切体会到生成式 AI 赋能重型企业治理流程的巨大潜力与落地底气。
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=r08lR0crgJ8&t=4s) 传统企业架构评审（ARB）流程高度依赖人工，从整理零散需求到产出首版 ASD 文档通常耗时长达 2 至 3 周。
- [00:04](https://www.youtube.com/watch?v=r08lR0crgJ8&t=4s) 团队的核心定位是将“企业架构治理流程本身代码化”（Enterprise Architecture as Code），而非单纯作为业务编码助手。
- [02:35](https://www.youtube.com/watch?v=r08lR0crgJ8&t=155s) 架构设计中理清确定性与概率性分工：非结构化理解交给大模型，深度嵌套的 JSON/ADF 解析与固定算法交由 Python 处理以节省 Token 并避免出错。
- [02:35](https://www.youtube.com/watch?v=r08lR0crgJ8&t=155s) 在架构自动化全流程中设置强制的人机协同（Human-in-the-loop）把关点，关键节点必须经由架构师人工复核后方可继续。
- [05:16](https://www.youtube.com/watch?v=r08lR0crgJ8&t=316s) 端到端自动化工作流可直接从混乱的会议纪要中提取时序并生成 Mermaid 架构图，将首版文档交付周期从数周缩短至 45 分钟。
- [05:16](https://www.youtube.com/watch?v=r08lR0crgJ8&t=316s) 通过架构重要性评估（无、轻微、重大）建立分级机制，自动为不同影响程度的项目匹配对应的 Jira Epic 及子任务清单。
- [08:09](https://www.youtube.com/watch?v=r08lR0crgJ8&t=489s) 在 Windsurf/Cascade 环境中借助 Atlassian MCP 协议与 Jira/Confluence 交互，并按标准化数字编号工作流分阶段触发任务。
- [08:09](https://www.youtube.com/watch?v=r08lR0crgJ8&t=489s) 必须对 AI Agent 的自主探路行为设置严格边界约束，例如当 MCP 断连时强制中止，防止其擅自调用未经审计的本地备用命令。
- [14:05](https://www.youtube.com/watch?v=r08lR0crgJ8&t=845s) 设立“收件箱（Inbox）”统一源文件目录，系统可自动追踪并增量摄取 SharePoint 导出材料、邮件及会议转录等各类非结构化输入。
- [16:32](https://www.youtube.com/watch?v=r08lR0crgJ8&t=992s) 架构师的核心价值在于权衡取舍与系统性决策，AI 的使命是接管耗费海量时间的机械性文档整理，解放专业生产力。
- [17:25](https://www.youtube.com/watch?v=r08lR0crgJ8&t=1045s) 实际落地场景包括自动比对第三方 API 版本差异（如 2.5 与 3.0），并自动闭环更新 Confluence 中的接口设计文档。
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=r08lR0crgJ8&t=4s) 传统企业架构评审的痛点与 AI 的切入点
在 First Horizon 银行，Kevin Kohut 一方面负责商业银行投资组合的企业架构支持，另一方面主导利用 AI 加速企业架构流程的专项行动。传统的架构评审委员会（ARB, Architecture Review Board）流程繁重且耗时，团队在过去几年中虽然建立了一套严密的操作标准，但完全依赖人工推进：从梳理零散材料到形成第一版草案，往往至少需要两周时间；随后还要在多轮需求调研与分析会议中不断迭代补充，最后再耗费数小时甚至数天制作最终的 ASD（Application Solution Design，应用解决方案设计）文档和 ARB 汇报材料以获取审批进入下一阶段。这套人工流程涉及复杂的 Confluence 模板、多个独立的 Confluence 空间以及大量互联系统，不仅极度耗时，而且极易因操作繁琐导致格式不一、规范难以落地。
团队对此并没有走常规的 AI 路线——比如写代码、做简单的 Copilot 辅助，而是致力于将“企业架构流程本身代码化”（Enterprise Architecture as Code）。Kevin 提到，会前他偶遇一家刚拿到 Y Combinator 投资的初创公司 CEO，对方兴奋地介绍其商业模式，结果 Kevin 听完直接笑称：“老兄，你刚才描述的就是我今天演讲要讲的内容。”这不仅印证了利用 AI 改造重型企业架构流程的巨大商业价值，也凸显了传统金融机构在这一创新方向上的前沿探索。
- **人工流程周期**：初版架构草案需至少 2 周，全流程沉淀并形成最终文档通常需要 2 到 3 周。
- **核心定位**：并非单纯辅助写业务代码（“vibe coding”），而是将整个企业架构治理流程转化为可执行的代码与工作流。
---
### [02:35](https://www.youtube.com/watch?v=r08lR0crgJ8&t=155s) 确定性与概率性：Python 与 AI 的分工哲学
在构建方案时，最关键的设计原则是理清“确定性”（deterministic）与“概率性”（probabilistic）的界限。大语言模型（LLM）擅长在海量、杂乱且非结构化的信息中建立关联，并按照规范整理出条理清晰的叙述性内容；但如果一个任务本质上是固定的算法操作，就绝不能依赖 AI。以 Confluence 的 ADF（Atlassian Document Format）为例，其本质是深度嵌套的复杂 JSON 模式（JSON Schema），AI 处理这类充斥着层层大括号与嵌套对象的数据时极易“数不清括号”而崩溃。相反，确定性极高的 Python 代码解析此类 JSON 轻而易举，不仅不出错，而且“完全不消耗任何 Token”（除了 AI Agent 触发脚本时的极少开销）。
团队因此确立了分工原则：优先审视耗时最长的人工环节，固定逻辑交由 Python 脚本确定性执行，非结构化理解留给大模型。同时，即便整个架构流程并不涉及敏感的真实客户数据、整体风险可控，系统仍然在关键决策节点设置了强制的“人机协同”（Human-in-the-loop）机制——工作流运行到关键位置会彻底暂停，等待企业架构师人工复核输出内容无误后，再允许继续执行。
```mermaid
flowchart TD
accTitle: 确定性任务与概率性任务的分工流向
subgraph Input["输入层"]
A["非结构化输入<br/>(会议纪要 / 邮件 / 厂商文档)"]
B["结构化任务<br/>(ADF JSON / Schema 校验)"]
end
subgraph Processing["处理层"]
C["AI 概率性推理<br/>(信息抽取 / 架构叙述 / Mermaid 生成)"]
D["Python 确定性算法<br/>(JSON 遍历 / API 交互 / 0 Token 开销)"]
end
subgraph Output["交付层"]
E{"人工复核节点<br/>(Human-in-the-loop)"}
F["Confluence / Jira<br/>最终企业架构资产"]
end
A --> C
B --> D
C --> E
D --> E
E -->|架构师确认| F
```
- **技术工具链分工**：确定性高频逻辑使用 Python（偶尔搭配 Node.js），解析 Atlassian ADF 格式；非结构化语义理解交由大模型。
- **治理原则**：在低数据风险场景下依然设立核心把关点，保障自动化输出的架构设计质量可控。
---
### [05:16](https://www.youtube.com/watch?v=r08lR0crgJ8&t=316s) 端到端架构自动化工作流与数据摄取
许多展厅展商误以为 First Horizon 正在开发直接与底层核心业务数据库交互的智能体，但 Kevin 澄清，这套系统的目标是纯粹围绕“架构文档编制与设计图生成”。完整流程涵盖：项目注册、架构重要性评估（Architectural Significance Assessment）、ASD 初始草案生成、审查与最终 ARB 批准。其中一个极为关键的机制是“迭代式摄取”（iterative ingestion）：团队设立了一个统一的源文件目录，架构师可随时将会议纪要、邮件往来、供应商文档等各种项目素材扔进该文件夹。
AI Agent 会根据预置的工作流脚本自动监控并迭代处理该目录。系统具备状态感知能力，能识别哪些文件已被处理过，只有当文件内容更新时才会重新提取。模型能直接从混乱的会议讨论记录中抽离系统交互时序，自动编写 Mermaid 代码生成时序图，并整合为一整套达到草案标准的架构文档。原本需要人工拉锯两到三周的整理工作，整个自动化流程仅需约 45 分钟即可交付。
- **架构重要性分级（Architectural Significance）**：
- **无（None）**：不具有实际架构重大影响，无需提交 ARB 上会，但仍需建档同步让各方知悉。
- **轻微（Minor）**：需履行标准子任务清单。
- **重大（Major）**：触发全量子任务与深度分析清单。
- **时间压缩倍率**：初版全套文档及 Mermaid 时序图由原本的人工 2-3 周骤降至 45 分钟。
---
### [08:09](https://www.youtube.com/watch?v=r08lR0crgJ8&t=489s) 编码环境实操：Windsurf、Cascade 与 Atlassian MCP
Kevin 随后展示了一段未经任何剪辑加速的原速实操录屏（因完整流程需 45 分钟且受限于会场网络设备，无法直接进行 20 分钟现场跑通）。演示界面左侧展示了严格标准化的项目工作流体系，采用了结构清晰的数字编号命名约定，便于按需触发：
| 编号区间 | 触发频率与作用 | 说明与典型任务 |
|:--- |:--- |:--- |
| **00 编号段** | 每一台电脑执行一次 | 本地开发与工作区环境初始化 |
| **10 编号段 (11, 12, 13...)** | 每一个架构项目运行一次 | 基础配置、初始化源目录与团队对齐 |
| **20 编号段 (21, 22...)** | 周期性 / 迭代执行 | 持续摄取文档、生成时序图、更新 ASD 草案 |
| **后续编号段** | 项目信息就绪后触发 | 面向 ARB 评审委员会生成最终汇报材料与评审包 |
在界面右侧，AI Agent（采用基于 VS Code 的 Windsurf/Devin 编辑器，内置 Agent 为 Cascade，底层模型采用 Claude 3.5 Sonnet / Opus）自主扫描源文件目录。Agent 会首先查询企业 Jira 实例，寻找是否存在对应的项目 Epic；若发现疑似匹配项会向人工确认“这看起来是该项目，是否关联？”，若未找到则询问是否新建 Epic。随后，根据评估出的架构重要性级别自动创建对应的系列子任务。
在此过程中，系统借助 Atlassian MCP（Model Context Protocol）服务器直接与 Jira 和 Confluence 实现通信。演示中出现了一个生动的插曲：MCP 服务一度发生断连，急于推进任务的 Cascade Agent 没有停下来报错提示，而是自动在工作区中寻找其他替代方案，试图调用本地安装的 Atlassian 命令行工具执行操作。Kevin 不得不紧急干预并制止它（“老兄，别这样”），手动重连 MCP 后才让它恢复正常路径。这促使团队在后续迭代中进一步收紧 Prompt 与规则约束：明确规定若 MCP 服务不可达，必须立即强制中止执行，绝不允许 Agent 自作主张尝试未经审计的后备路径。
- **实操环境底座**：基于 VS Code 定制的智能编辑器环境，搭载 Cascade Agent。
- **多模型对比观察**：Kevin 在 Claude Opus、Claude Haiku 以及 GPT 系列代码模型上对比过该工作流；尽管不同 Agent 行为偏好各异（例如在遇到 MCP 异常时的探路方式不同），但由于团队制定的工作流规则极其严密精确，各模型最终输出的架构文档结构与内容几乎完全一致。
### [14:05](https://www.youtube.com/watch?v=r08lR0crgJ8&t=845s) 自动化生成与收件箱机制：处理非结构化输入
向 AI 明确指示“什么该做、什么不能做”就像给五岁小孩定规矩一样直接。在该架构流水线中，系统会自动创建 Confluence 页面、生成 Jira Epic、用户故事（User Stories）以及配套的具体任务，并严格跟踪记录所有已执行的操作。这意味着当重新运行流程时，用户完全不需要手动重新加载任何上下文或提醒 AI 调取历史记忆；系统只需要访问预先指定的项目内容总目录即可。
系统会主动扫描并识别被称为“收件箱（Inbox）”的源材料目录。由于各个产品团队的工作习惯各异，输入的内容完全允许是非结构化的任意子目录结构。无论是从 SharePoint 文档库中批量导出的整套技术资料、往来的沟通邮件，还是会议录音转录文本，都可以直接一股脑丢进该源文件夹中，由系统自动完成扫描与解析。
```mermaid
flowchart TD
accTitle: 文档自动化处理流程
subgraph Input["输入源 (Inbox)"]
A["SharePoint 文档库 / 邮件"]
B["会议转录文本 / 规范"]
end
subgraph AIWorkflow["AI 解析与脚手架引擎"]
C["本地目录扫描与变更识别"]
D["内容解析与任务拆解"]
end
subgraph Output["交付物生成"]
E["Confluence 架构页面"]
F["Jira Epics & Stories"]
end
A --> C
B --> C
C --> D
D --> E
D --> F
```
- 系统自动追踪已处理内容，再次运行无需重复注入上下文或重置记忆。
- 支持高度异构的输入格式：SharePoint 导出文件、邮件线程、会议逐字稿等均可直接作为源数据。
---
### [15:43](https://www.youtube.com/watch?v=r08lR0crgJ8&t=943s) 项目管理与多团队推广：从零脚手架到跨部门采用
当系统完成首次初始化处理后，会列出当前已存在的各个项目目录，并提供一个直观的交互菜单供用户选择：既可以选择继续处理已有的具体项目，也可以选择“从空白开始（Work from blank）”。在没有任何源素材的情况下选择从零开始，系统便会依次向用户提问，例如询问“项目名称是什么”，随后逐一生成各项骨架定义（Stub out）。虽然初始骨架的内容相对简略，但能快速搭建起标准的项目结构。
这种高效的工作模式迅速引起了周围同事的注意。不仅企业架构团队内部的其他成员主动要求接入使用，就连企业架构部门之外的许多外部产品团队也纷纷前来咨询：“嘿，我们怎样才能用上这个工具？”越来越多的团队开始意识到，自己日常繁重的文档与规划流程同样可以借助这套工作流实现自动化。
---
### [16:32](https://www.youtube.com/watch?v=r08lR0crgJ8&t=992s) 架构师的核心价值：AI 不会取代真正的决策
面对现场观众心中普遍存在的疑虑——“我是不是正在用 AI 把自己的饭碗给写没了？”——答案是坚决的否定。企业中始终存在大量必须由人类专家拍板的合法架构决策，这正是专业资历与多年企业运作经验不可替代的价值所在。
架构师的真正价值从来不在于“在 Confluence 里撰写描述性文字的能力”，即便文笔出色确实有所助益。团队的核心定位是把握系统架构的方向与复杂权衡，而 AI 的使命则是接管那些需要翻阅海量资料、机械拼凑文档的“繁琐事务性工作（Busy work）”，将专业人才从低效消耗中彻底解放出来。
> “我们的价值不在于我们在 Confluence 里写叙述性文档的能力……让我们用 AI 去生成那些需要耗费大量时间硬啃的繁琐事务吧。”
---
### [17:25](https://www.youtube.com/watch?v=r08lR0crgJ8&t=1045s) 实际应用示例：第三方 API 版本差异对比与文档自动更新
除了日常架构设计，该模式还被灵活运用于第三方供应商接口变更的追踪上。在某个正在进行的新项目中，合作的第三方供应商频繁更新其 API。面对刚刚发布的 3.0 版本规范，可以通过 AI 直接对比 2.5 版本与 3.0 版本的接口定义，快速分析并提炼出所有的变更细节。
随后，AI 会将这些变更总结输出为一份 Markdown（.md）文件。只需将该 Markdown 摘要与最新的官方文档一同放入项目的 `sources` 文件夹中，重新触发摄取流程，系统便会自动检测到新加入的文档，完成增量分析，并自动同步更新对应的 Confluence 页面，整个过程无缝衔接且无需人工重写架构记录。
- **版本比对**：利用 AI 迅速比对 API 2.5 与 3.0 规范，提炼接口差异点。
- **闭环更新**：将 AI 生成的变更总结 Markdown 与新版文档放入源文件夹，系统自动重新摄取并刷新 Confluence 架构文档。
---
### [18:40](https://www.youtube.com/watch?v=r08lR0crgJ8&t=1120s) 结语与会后交流
由于单场演讲时间有限，现场无法展开大范围的自由提问环节。演讲者表示将在演讲结束后留在会场门外的大厅区域，欢迎有具体疑问的参会者前来深入探讨与交流。
演讲者对现场观众在傍晚时段依然坚持参会表达了由衷的感谢，深知在经历了一整天密集的会议议程后参加傍晚专场非常疲惫，并祝愿本次分享的内容能为各位参会者在各自企业的 AI 落地实践与架构转型旅程中提供切实的启发与帮助。
## Notable quotes
> [00:04](https://www.youtube.com/watch?v=r08lR0crgJ8&t=4s) 老兄，你刚才描述的就是我今天演讲要讲的内容。 — Kevin Kohut
> [02:35](https://www.youtube.com/watch?v=r08lR0crgJ8&t=155s) 完全不消耗任何 Token — Kevin Kohut
> [08:09](https://www.youtube.com/watch?v=r08lR0crgJ8&t=489s) 老兄，别这样 — Kevin Kohut
> [14:05](https://www.youtube.com/watch?v=r08lR0crgJ8&t=845s) 什么该做、什么不能做 — Kevin Kohut
> [15:43](https://www.youtube.com/watch?v=r08lR0crgJ8&t=943s) 从空白开始 — Kevin Kohut
> [15:43](https://www.youtube.com/watch?v=r08lR0crgJ8&t=943s) 项目名称是什么 — Kevin Kohut
> [15:43](https://www.youtube.com/watch?v=r08lR0crgJ8&t=943s) 嘿，我们怎样才能用上这个工具？ — Kevin Kohut
> [16:32](https://www.youtube.com/watch?v=r08lR0crgJ8&t=992s) 我是不是正在用 AI 把自己的饭碗给写没了？ — Kevin Kohut
> [16:32](https://www.youtube.com/watch?v=r08lR0crgJ8&t=992s) 我们的价值不在于我们在 Confluence 里写叙述性文档的能力……让我们用 AI 去生成那些需要耗费大量时间硬啃的繁琐事务吧。 — Kevin Kohut
## Mentioned
Kevin Kohut, First Horizon Bank, Y Combinator, Confluence, Jira, Atlassian, ADF (Atlassian Document Format), Python, Node.js, Mermaid, Windsurf, Devin, Cascade, Claude 3.5 Sonnet, Claude Opus, Claude Haiku, GPT, Model Context Protocol (MCP), SharePoint
## Video description
Kevin Kohut - VP, Enterprise Architecture, First Horizon Bank
How we used AI workflows to create versioned Enterprise Architecture assets in hours instead of weeks.
Enterprise Architecture projects involve lots of discovery and analysis followed by manually creating sequence diagrams, architecture designs, and relevant documentation. In this session we will show, in real time, taking a D&A meeting transcript and create initial EA documentation and sequence diagrams,
Whether you are an Enterprise Architect, Product Owner, Business Analyst, or any other stakeholder in a product team you will discover how AI can help accelerate your own projects.
[Source](https://www.youtube.com/watch?v=r08lR0crgJ8)
Source quotes
[0:04] Kevin Kohut: 老兄，你刚才描述的就是我今天演讲要讲的内容。
[2:35] Kevin Kohut: 完全不消耗任何 Token
[8:09] Kevin Kohut: 老兄，别这样
[14:05] Kevin Kohut: 什么该做、什么不能做
[15:43] Kevin Kohut: 从空白开始
[15:43] Kevin Kohut: 项目名称是什么
[15:43] Kevin Kohut: 嘿，我们怎样才能用上这个工具？
[16:32] Kevin Kohut: 我是不是正在用 AI 把自己的饭碗给写没了？
[16:32] Kevin Kohut: 我们的价值不在于我们在 Confluence 里写叙述性文档的能力……让我们用 AI 去生成那些需要耗费大量时间硬啃的繁琐事务吧。
Source quotes
[0:04] Kevin Kohut: Gathering information and creating an initial draft document takes at least two weeks.
[0:04] Kevin Kohut: Iterating through discovery and analysis (D&A) meetings requires continuously updating documentation.
[0:04] Kevin Kohut: Assembling the final Application Solution Design (ASD) and ARB presentation slides demands several additional hours, if not days, before finally seeking approval to move to the next phase.
[0:04] Kevin Kohut: The manual process is complicated, messy, and inconsistent.
[1:37] Kevin Kohut: Know when to use probabilistic vs. deterministic logic
[1:37] Kevin Kohut: Large Language Models (LLMs) excel at sifting through disparate, unstructured content (transcripts, emails, vendor docs) to make sense of information. However, algorithmic tasks should remain programmatic.
[1:37] Kevin Kohut: Use code for fixed structures
[1:37] Kevin Kohut: Python handles nested data structures and fixed schemas far better than LLMs.
[1:37] Kevin Kohut: Target manual bottlenecks first
[1:37] Kevin Kohut: Keep humans in the loop at critical junctions
[1:37] Kevin Kohut: The automated workflows are designed to pause at key decision points, requiring approval from an Enterprise Architect before proceeding.
[3:10] Kevin Kohut: Running deterministic operations via Python scripts rather than LLM prompts also drastically reduces API token consumption.
Original transcript
[0:04] I have a day job at First Horizon and that is
to provide enterprise architecture support for
[0:10] a commercial banking portfolio. It's it's cool.
I like it. But I also have another hat where I
[0:17] am heading up AI uh initiatives specifically to
accelerate enterprise architecture. Um, some of
[0:28] you, if not all of you, have probably participated
in some kind of ARB review of something or
[0:33] whatever. We have an entire process that's been
developed over the last couple years of how to do
[0:39] that. And if you do it manually and you try to go
through all the information, it takes at least two
[0:44] weeks to get to a point where you have just even a
draft ready. Then you have to iterate through all
[0:50] the discovery and analysis meetings and keep
adding to it. Then you finally spend another
[0:55] couple of hours if not days to put the final ASD
together and the ARB presentation to then go get
[1:02] approval so so you can go to the next phase. Well,
we're trying to speed that up. So the problem is
[1:09] it's complicated and it's time consuming. We
have confluence templates. We have um different
[1:17] confluence spaces that we're using. We've got
lots of of interacting systems. And as you can
[1:24] see from that nice little graphic, it's manual.
It's messy. And it's hard to be consistent. It's
[1:30] hard to follow all the procedures. It's hard to
know if everything was done correctly. And so what
[1:37] did we do? Well, we wanted to identify what were
the critical success factors. If you're going to
[1:45] use AI for something other than all the typical
use cases for AI, right? Probably all of us or at
[1:53] least most of us have used some kind of AI to code
something to vibe code to code something else.
[2:00] This is not what we're talking about here. We're
talking about the enterprise architecture process
[2:06] itself as code. Before this meeting, I was talking
to a CEO of a new startup, a Y Cominator startup,
[2:14] and he explained what his new startup does. And I
said, "Dude, you just described my session today."
[2:21] So there's a Y Cominator startup that managed to
convince Y Cominator to fund them to to offer a
[2:28] service that does something very much like this.
So you need to understand when to be deterministic
[2:35] versus probabilistic. Okay, AI is great when you
need the the capacity of a model to go through all
[2:47] sorts of disparit information and try and make
sense of it to put it into something that is
[2:53] uh like I said according to our our procedures
and our different templates and so forth. But if
[3:00] you want to do something that basically follows
an algorithm, don't use AI for it. I use Python.
[3:10] I'm a Python guy. Uh do a little Node.js as well
and anything else that might come around my way.
[3:17] But what I like is to say, hey, Python knows how
to, for example, iterate through very complex
[3:26] JSON schema. AI struggles with it. It just they it
loses track of how many, you know, how many nested
[3:34] uh curly braces there are and all these nested
objects. And if any of you worked with Confluence,
[3:39] the Confluences ADF, which is the Atlassian
document format, is some of the most god- aful
[3:45] JSON you're ever going to look at. And AI just
has a hard time dealing with it. Python doesn't.
[3:51] So if you can figure out a process where Python
just follows an algorithm that's the same thing
[3:58] over and over again, do it. And guess what? Python
doesn't cost you any tokens. Zero tokens. Well,
[4:04] maybe not zero. You're using an AI agent to launch
the Python code. So that costs something, right?
[4:11] And then you always start with the manual process.
Look at what people are doing manually. If there
[4:19] are already things that are automated, true,
they might benefit from having AI added onto it,
[4:26] but start with the stuff that's taken the longest
time, and that's the manual stuff. So look at that
[4:34] and say, what what can we do with it? And then
obviously, you've got to know where to put human
[4:40] in the loop. the process I put together several
times. It's ordered to just stop completely and
[4:48] give the enterprise architect or whoever is using
it to look at the output, make sure it's good and
[4:56] such. In this use case, there's really not a high
risk because we're not dealing with any actual
[5:02] customer data. This is all, you know, architecture
diagrams and documents and narratives and such.
[5:10] So, it's not real high-risisk, but we still want
to have a human in the loop where we have critical
[5:16] decision points. So, what's the solution? And
it's funny because I've been talking to a lot
[5:24] of the vendors in the exhibition hall and every
time I describe, you know, they always ask me,
[5:29] you know, oh, Kevin, you're a speaker.
What are you talking about? And I say,
[5:32] well, I give the same spill I gave you guys when
we started. And then they immediately think, oh,
[5:40] you're like writing AI agents to interact with
with all your systems that are running in your
[5:46] organization. I go, no, that's not what this is
about. We're not integrating with our databases
[5:52] and all this on this. We're using AI to develop
architectural documentation and the diagrams and
[6:02] things that go along with it. And so the idea
is we need to register an initiative then we
[6:11] need to assess okay is it we have what we call an
architectural significance is it um is it a non
[6:20] does it need any analysis or is it minor or is it
major and we have all sorts of checklists for that
[6:25] um then we want to draft the ASD document the you
know um application solution design and then it's
[6:34] the initial draft so it won't have a lot in it.
Then we want to review it and then we finally
[6:39] get to ARB approval and I don't know why I forgot
to put it in there but there's also a a iterative
[6:46] ingestion phase where you put source material
in a folder. So, meeting transcripts, email
[6:55] uh you know uh content, vendor documentation,
anything and everything that relates to the
[7:03] project and you iterate through that. You tell
your AI agent to launch a workflow that is going
[7:10] to process that and it keeps track. It knows if
it already processed something, it won't process
[7:17] it again and it'll know if it changes. And that's
all through a very structured workflow process,
[7:24] several workflows that the AI agent follows to
ingest and process information. And it'll do
[7:33] things like use mermaid code to generate sequence
diagrams based on the narrative it pulls out of
[7:39] the meeting transcript. and it gets to a draft
level set of documentation in about 45 minutes.
[7:50] And it usually would take us anywhere from two to
three weeks to get to that to that level doing it
[7:57] all manually. And so that's the solution now.
And I purposely kind of shot through all that
[8:09] because I want to spend a little bit of time on
this next uh thing. We're going to show uh an
[8:16] embedded video of of the proc part of the process
actually working. Okay. Now, I think it's going
[8:24] to show up pretty good. Um not not sure how easy
it'll be to see, but um my original plan was I
[8:34] wanted to actually run the workflow here live, but
it's only a 20-minut session. Remember I told you
[8:40] it's 45 minutes to we have to use their equipment
and the internet and all that. I'm thinking, you
[8:47] know what? It's just not going to work. So, I did
the next best thing. And this is an unedited. It's
[8:52] not the entire process. It's unedited. I haven't
sped it up or did anything. I just went in and I
[8:59] started. And so what we're going to do is if you
can get that playing. There we go. So what we're
[9:09] looking at here is um the left side is the project
and you notice it's got all sorts of workflows. 11
[9:19] 12 13 right 21 22 and then like that's a numbering
scheme to the type of workflow. So typically run
[9:28] once per project are the teams typically run once
period per laptop is the 00 that just sets up your
[9:37] local environment. And then we have the stuff you
do after you think you've got enough information
[9:43] and you're ready to do the ASD presentation for
the um architectural review board. On the right
[9:48] hand side, you see the agent going through and
doing its thing and it's it's looking at the
[9:55] source folder where all those source files were
put. It looks to see if there's an existing Jira
[10:03] ticket or Jira epic for that project. If it thinks
it finds one, it says, "This looks like it's this
[10:09] project. Is it?" And if it doesn't, then it says,
"Hey, I don't see a project. Do you want me to
[10:13] create a new Jira epic for this?" And you say,
"Yep." And then it'll create the epic. Then it'll
[10:19] um create the subtasks for that epic that all has
to happen. And what are those subtasks? Well, it
[10:25] depends. Remember the architectural significance.
So you say if it's a minor architectural
[10:32] significant, there's a set of things you have to
do. If it's major, there's more. And if it's what
[10:38] we call none, which is kind of a weird name
for it, it means it doesn't really have any
[10:43] architectural significance. So, we don't really
need to go to the architectural review board,
[10:48] but it is still a project we want people to be
aware of and understand that it's happening. Okay.
[10:54] And so, what this is doing is it's going through
and interacting with uh Confluence and Jira. Okay.
[11:04] And we're using the Atlassian MCP server. And
the cool thing about that is it just works right
[11:13] now. You got to be mindful of the gotchas. Now, I
didn't I have no way to control the the playback
[11:25] um and such, so it's hard to stop. But you may
have noticed that there were a couple times where
[11:32] uh I had to stop the agent and get it back on
the right track cuz it the MCP server was not
[11:40] connected. If you know how this works, this is
Devon by the way, which is a fork of VS Code and
[11:48] um it's what we use in enterprise architecture.
And the agent in Devon is called Cascade. And so,
[11:56] and the model I was using for this is um Claude
Opus 4.6. And Cascade as an agent is really eager
[12:07] to find a way through. Find a way through. And
so my MCP server wasn't connected. So when it
[12:15] couldn't connect to Confluence, it didn't stop and
ask me, "Hey, I can't connect. You want to check?"
[12:23] it just tried to find other ways and I have uh
another tool installed in my workspace. Um that's
[12:30] a command line tool to interact with Atlassian
products. So it tried to do that and I'm like
[12:36] dude no. So I had to stop it. I said hey I just
connected the MCP server. Try again. And now I'm
[12:44] going to work on that. I'm going to try and revise
the workflow so that it's more explicit to the
[12:50] agent. Do not ever use TWWG or anything. If the MC
if you can't find the MCP server, stop. Okay? So,
[13:01] you got to work that through. And it varies
from agent to agent and model to model. I ran
[13:08] this against um three different models. I ran it
against Opus 4.8. I ran it or 4.6, excuse me. I
[13:17] ran it against Haiku 4.5, I believe. and I ran it
through um GPT codeex I forget the version five
[13:27] something and here's the thing the agent behavior
of of whether it tries to use the MCP server or
[13:36] not was a little different but the output was
almost identical and that's because the workflows
[13:46] that I used are worded so specifically and there's
rules that they have to be followed. And so the
[13:56] way you get AI to be as deterministic as you can
possibly get it is I like to say talk to me like
[14:05] I'm a 5-year-old. Tell it explicitly what it needs
to do and what it can't do. And so that's what's
[14:16] what's happening here is it goes through and it
creates the confluence pages. It creates the Jira
[14:25] uh uh epics and the and the user stories and
tasks that go along with it. And it keeps track
[14:33] of everything that it did. So if I rerun this, I
don't have to tell it to load any kind of context.
[14:40] I don't need need to tell it to go find a memory.
All it does is present me the content folder that
[14:48] I've designated as where all my my my content for
these projects live. And it'll look through and
[14:56] it'll say, okay, I see that you have four folders
in the what we call the inbox, which that's where
[15:04] the source material goes. That and that's
unstructured. It's a folder. underneath that
[15:10] folder. It can be any structure you want. That's
because that's how product teams work. Sometimes
[15:17] I get a SharePoint document library as where all
the documentation is. So what do I do with that? I
[15:24] copy all that document library down and put it
in that source folder. Sometimes it's emails,
[15:31] sometimes it's meeting transcripts, right? Put it
all in there. And so what'll happen is it'll look
[15:35] through that and say I find five folders here
and then in the after it does the first process
[15:43] and initializes it then it's here's all these
folders that are projects already in place and so
[15:50] it'll present me a little menu of which one do you
want to work on or do you want to work from blank
[15:56] meaning I don't have any source and then it'll
just prompt me for everything. What's the name
[16:00] of the project? it'll just go through and prompt
everything and it'll stub it out. Obviously,
[16:05] it won't have a lot of content, but it'll it'll
uh at least get all that done. Um, I've already
[16:12] got other people on on the team wanting to use it.
And now we've got people outside of the enterprise
[16:17] architecture organization that are asking me, hey,
how how do how do we get in on that? And some of
[16:23] the product teams are realizing, hey, we could
probably do this. Okay, now I got to address one
[16:32] thing about this that some of you are probably
thinking of. Did I just use AI to write me out
[16:39] of a job? No. Because there are still legitimate
architectural decisions that need to be made. And
[16:48] that's why I have absolute job security because
I know that I've got the years of experience
[16:55] of understanding how stuff works in enterprise
organizations. And that is the value that that
[17:03] our enterprise architecture team has, right? Our
value is not in our ability to write narrative
[17:10] code in in in confluence. I mean, it's helpful if
we're good at that for sure, but that's the idea.
[17:16] Let's use AI to generate the things that is like
the busy work of just trying to ream through. Um,
[17:25] I'll give one more example that I use this with.
I don't have an actual workflow for this yet,
[17:32] but we're working with a third party vendor
who keeps updating their API. It's a it's a new
[17:39] project. And so I said, "Hey, they just released
3.0. can you look at the 2.5 spec then look at the
[17:47] 3.0 nospec tell me what changed right and it reads
through it all and says okay and then I say okay
[17:55] write an MD file a markdown file and then what
do I do with that markdown file I put it in the
[18:04] um that sources folder that I was telling you
about and I put the updated documentation in
[18:11] that sources folder so I've already had AI review
it and then I run the ingestion process. It'll go
[18:19] look at it and it'll say, "Oh, you've got a
new MD file in there and a new documentation
[18:25] file. Let me process that." And then it'll
update the Confluence pages, do all that,
[18:30] and then come back and say, "Hey, we're good."
So, we only got um we only got uh a minute or so.
[18:40] Um I am going to hang out right outside the hall
for a little bit if you want to talk to me. happy
[18:46] to take questions um in this really short time
format. We unfortunately can't do like questions
[18:51] from the floor because it just doesn't work.
But um I really appreciate you hanging out. I
[18:57] know these late afternoon sessions are the brutal
because you just been at it all day. So I'm really
[19:02] pleased that I've got a decent crowd here tonight.
Um and I'm happy to talk about it and such. So,
[19:08] uh, I want to thank you for coming and I want to,
um, just again reiterate that happy to take any
[19:14] questions that you might have and hopefully this
helps you in your AI journey. Thank you so much.
