From 927a3f02cadf2f95e995f8f847b62fa947023cb3 Mon Sep 17 00:00:00 2001 From: Andy Braren Date: Tue, 4 Nov 2025 17:09:04 -0500 Subject: [PATCH 01/55] UI revamp --- FRONTEND_UI_UPDATE_PROMPT.md | 505 ++++ static-prototype/README.md | 95 + ... 2025_10_30 15_56 EDT - Notes by Gemini.md | 55 + ... 2025_10_31 14_29 EDT - Notes by Gemini.md | 74 + ...n 2 - 2025_10_31 14_29 EDT - transcript.md | 856 ++++++ .../curated_feedback.md | 499 +++ .../prototype_version_1_feedback/my_notes.txt | 18 + .../prototype_version_1_feedback/plan.md | 766 +++++ .../slack_feedback.txt | 30 + static-prototype/index.html | 420 +++ static-prototype/integrations/page.html | 130 + static-prototype/projects/new/page.html | 136 + .../create-api-tests/page.html | 274 ++ .../implement-login-flow/page.html | 310 ++ .../projects/sample-workspace/info/page.html | 228 ++ .../projects/sample-workspace/keys/page.html | 295 ++ .../optimize-queries/headless.html | 303 ++ .../projects/sample-workspace/page.html | 1059 +++++++ .../sample-workspace/permissions/page.html | 318 ++ .../projects/sample-workspace/rfe/page.html | 262 ++ .../sample-workspace/session-1/headless.html | 385 +++ .../sample-workspace/session-1/page.html | 2692 +++++++++++++++++ .../sample-workspace/sessions/page.html | 273 ++ .../sample-workspace/settings/page.html | 340 +++ .../setup-database/headless.html | 307 ++ static-prototype/rfe.md | 1092 +++++++ static-prototype/styles.css | 527 ++++ 27 files changed, 12249 insertions(+) create mode 100644 FRONTEND_UI_UPDATE_PROMPT.md create mode 100644 static-prototype/README.md create mode 100644 static-prototype/design_path/prototype_version_1_feedback/Chat UI Feedback - 2025_10_30 15_56 EDT - Notes by Gemini.md create mode 100644 static-prototype/design_path/prototype_version_1_feedback/Chat UI feedback session 2 - 2025_10_31 14_29 EDT - Notes by Gemini.md create mode 100644 static-prototype/design_path/prototype_version_1_feedback/Chat UI feedback session 2 - 2025_10_31 14_29 EDT - transcript.md create mode 100644 static-prototype/design_path/prototype_version_1_feedback/curated_feedback.md create mode 100644 static-prototype/design_path/prototype_version_1_feedback/my_notes.txt create mode 100644 static-prototype/design_path/prototype_version_1_feedback/plan.md create mode 100644 static-prototype/design_path/prototype_version_1_feedback/slack_feedback.txt create mode 100644 static-prototype/index.html create mode 100644 static-prototype/integrations/page.html create mode 100644 static-prototype/projects/new/page.html create mode 100644 static-prototype/projects/sample-workspace/create-api-tests/page.html create mode 100644 static-prototype/projects/sample-workspace/implement-login-flow/page.html create mode 100644 static-prototype/projects/sample-workspace/info/page.html create mode 100644 static-prototype/projects/sample-workspace/keys/page.html create mode 100644 static-prototype/projects/sample-workspace/optimize-queries/headless.html create mode 100644 static-prototype/projects/sample-workspace/page.html create mode 100644 static-prototype/projects/sample-workspace/permissions/page.html create mode 100644 static-prototype/projects/sample-workspace/rfe/page.html create mode 100644 static-prototype/projects/sample-workspace/session-1/headless.html create mode 100644 static-prototype/projects/sample-workspace/session-1/page.html create mode 100644 static-prototype/projects/sample-workspace/sessions/page.html create mode 100644 static-prototype/projects/sample-workspace/settings/page.html create mode 100644 static-prototype/projects/sample-workspace/setup-database/headless.html create mode 100644 static-prototype/rfe.md create mode 100644 static-prototype/styles.css diff --git a/FRONTEND_UI_UPDATE_PROMPT.md b/FRONTEND_UI_UPDATE_PROMPT.md new file mode 100644 index 000000000..dc8067ac2 --- /dev/null +++ b/FRONTEND_UI_UPDATE_PROMPT.md @@ -0,0 +1,505 @@ +# Frontend UI Update Prompt for Claude 4.5 Sonnet + +## Objective +Update the current vTeam Next.js/React frontend UI (located at `components/frontend`) to match the design and user experience of the static HTML prototype (located at `static-prototype`). + +--- + +## Context + +### Current Frontend +- **Location**: `/Users/abraren/acorn/local/code/vTeam/components/frontend` +- **Tech Stack**: Next.js 15, React, TypeScript, TailwindCSS, Shadcn/ui, React Query +- **Architecture**: App Router with Server/Client Components + +### Static Prototype Reference +- **Location**: `/Users/abraren/acorn/local/code/vTeam/static-prototype` +- **Files**: HTML pages with inline CSS and vanilla JavaScript +- **Purpose**: Design reference and UX flow demonstration + +### Design Guidelines +- **MUST READ**: `components/frontend/DESIGN_GUIDELINES.md` +- **MUST READ**: `components/frontend/COMPONENT_PATTERNS.md` + +--- + +## Key Design Changes to Implement + +### 1. **Branding & Header** +**Prototype Reference**: `static-prototype/index.html` (lines 10-54) + +**Changes Needed**: +- Change branding from "vTeam" to **"Ambient Code Platform"** +- Update header logo/title styling to match prototype +- Implement user dropdown menu in header with: + - User email display + - User initials avatar bubble + - Dropdown arrow animation + - "Integrations" link + - "Logout" button +- Use prototype's header styling: white background, subtle border-bottom + +**Current Location**: `components/frontend/src/components/navigation.tsx` + +--- + +### 2. **Terminology Changes** +**Prototype shows different terminology throughout:** + +| Current Term | New Term (Prototype) | +|--------------|---------------------| +| "Projects" | "Workspaces" | +| "RFE Workflows" page | Integrated into workspace tabs | +| Page title on projects list | "Workspaces" | +| Create button | "New Workspace" | + +**Affected Files**: +- `src/app/projects/page.tsx` +- `src/components/navigation.tsx` +- `src/components/page-header.tsx` +- All project-related page titles and descriptions + +--- + +### 3. **Projects/Workspaces List Page** +**Prototype Reference**: `static-prototype/index.html` + +**Changes Needed**: + +#### Header Section +- Title: "Workspaces" +- Description: "Select a workspace or create a new one to get started" +- Actions: "Refresh" button + "New Workspace" button + +#### Table Design +- **Columns**: Name, Description, Sessions, Created, Actions +- **Special column**: "Sessions" shows: + - Total session count + - Badge with running session count (if any) with spinner icon + - Example: `4` + `1 Running` +- **Actions column**: Single delete button (trash icon) +- **Name column**: Link styled in blue (`#1e40af`) +- Clean white card with subtle borders + +#### Modal for Creation +- **Modal Title**: "Create New Workspace" +- **Fields**: + - Workspace Name (with validation message) + - Display Name + - Description (textarea) +- Pre-filled with auto-incrementing defaults (e.g., `demo-user-workspace-1`) +- Modal styling matches prototype's clean design + +**Current Location**: `src/app/projects/page.tsx` + +--- + +### 4. **Workspace Detail Page (Project Detail)** +**Prototype Reference**: `static-prototype/projects/sample-workspace/page.html` + +**Major Redesign Needed**: + +#### Layout +- **Left Sidebar Navigation** (vertical menu with icons): + - Sessions (star icon) - Active by default + - Sharing (users icon) - Previously "Permissions" + - Workspace Settings (settings icon) + +#### Breadcrumbs +- Format: `Workspaces / {workspace-name}` +- Located above page title + +#### Page Header +- Show workspace name as title +- Show workspace description below title + +#### Main Content Area - Tabbed Interface +The prototype shows different content sections that switch via sidebar navigation: + +**A. Sessions Tab (Default)** +- Title: "Agentic Sessions" +- Actions: Refresh + "New Session" button +- Table columns: + - Session Name (with description underneath) + - Status (badge with icon: Running/Completed) + - Mode (interactive/headless) + - Model (e.g., claude-3.5-sonnet) + - Created (relative time) +- Clickable rows that navigate to session detail +- Status badges with SVG icons (spinning loader for "Running", checkmark for "Completed") + +**B. Sharing Tab** (Previously "Permissions") +- Title: "Sharing" +- Description: "Users and groups with access to this workspace and their roles" +- Table columns: + - Users/Groups (name + subtitle) + - Type (User/Group badge) + - Role (Admin/View badge) + - Actions (delete button) +- Action: "Grant Permission" button + +**C. Workspace Settings Tab** +Multiple cards with different settings sections: + +1. **General Settings Card** + - Display Name (editable) + - Workspace Name (read-only with help text) + - Description (textarea) + - "Save Changes" button + +2. **Runner Secrets Card** + - Runner Secret dropdown selector + - Anthropic API Key (required field with asterisk) + - Additional Secrets section: + - Dynamic key/value pairs + - "Add Secret" button + - Grid layout: Key | Value | Delete button + - "Save Secrets" button + +3. **Resource Limits Card** + - Max Concurrent Sessions + - Max RFE Workspaces + - Storage Limit (GB) + - "Update Limits" button + +4. **API Keys Card** (embedded in settings) + - Table of API keys + - Columns: Name, Created, Last Used, Role, Actions + - Actions: Refresh + "Create Key" button + +**Current Locations**: +- `src/app/projects/[name]/page.tsx` +- `src/app/projects/[name]/layout.tsx` +- `src/app/projects/[name]/permissions/page.tsx` +- `src/app/projects/[name]/settings/page.tsx` + +--- + +### 5. **Session Creation Modal** +**Prototype Reference**: `static-prototype/projects/sample-workspace/page.html` (lines 698-776) + +**Features to Implement**: + +#### Basic Configuration +- **Model Dropdown**: + - Claude Sonnet 3.7 (default) + - Claude Opus 4.1 + - Claude Opus 4 + - Claude Sonnet 4 + - Claude Haiku 3.5 + +#### Headless-Specific Field +- **Agentic Prompt** textarea (only shown for headless mode) +- Help text: "Provide detailed instructions for the AI to execute without user interaction" + +#### Advanced Settings (Collapsible Accordion) +- **Button**: "Change Default Model Settings" with chevron +- **Fields when expanded**: + - Temperature (0.0 - 2.0, step 0.1) + - Timeout (60-1800 seconds) + - Max Output Tokens (100-8000) + - **Bring Your Own Key section**: + - Anthropic API Key input (password field) + - "Save key for future sessions" checkbox + - Help text: "Optional: Use your own Anthropic API key for this session" + +#### Modal Actions +- Cancel button +- "Create Session" button + +**Implementation**: +- Create new component: `src/components/session-config-dialog.tsx` +- Use Shadcn Dialog component +- Use Accordion component for advanced settings +- Integrate with session creation flow + +--- + +### 6. **Sessions List Page** +**Prototype Reference**: `static-prototype/projects/sample-workspace/sessions/page.html` + +**Design**: +- Breadcrumbs: `Workspaces / {workspace-name} / Sessions` +- Title: "Agentic Sessions" +- Description: "AI-powered coding sessions for your project" +- Left sidebar with workspace navigation +- Table with sessions (same as on workspace detail page) + +**Current Location**: `src/app/projects/[name]/sessions/page.tsx` + +--- + +### 7. **Visual Design System** + +#### Colors (from `static-prototype/styles.css`) +```css +Primary Blue: #1e40af (links, primary buttons) +Hover Blue: #1d4ed8 +Background: #f8fafc (page background) +Card Background: white +Borders: #e2e8f0 +Text Primary: #333 +Text Secondary: #64748b +Text Muted: #374151 +Success Green: #166534 (background: #dcfce7) +Warning Yellow: #92400e (background: #fef3c7) +Error Red: #991b1b (background: #fee2e2) +Info Blue: #1e40af (background: #dbeafe) +``` + +#### Typography +- Font Family: `-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif` +- Page Title: `2rem`, `font-weight: bold` +- Card Title: `1.25rem`, `font-weight: 600` +- Body: `1rem`, `line-height: 1.6` + +#### Spacing & Layout +- Container: `max-width: 1200px`, centered +- Card Border Radius: `0.5rem` +- Button Border Radius: `0.375rem` +- Standard Padding: Card header/content `1.5rem` + +#### Buttons +- **Primary**: Blue background (`#1e40af`), white text +- **Secondary**: White background, gray border (`#d1d5db`), gray text +- **Icons**: Inline SVG, 14-16px size +- **Hover States**: Subtle background color changes + +#### Tables +- Header Background: `#f8fafc` +- Border: `#e2e8f0` +- Row Hover: `#f8fafc` +- Cell Padding: `0.75rem` + +#### Badges +- Border Radius: `9999px` (pill shape) +- Padding: `0.25rem 0.75rem` +- Font Size: `0.75rem`, `font-weight: 500` +- With inline SVG icons (12px) + +#### Modals +- Backdrop: `rgba(0, 0, 0, 0.5)` +- Content: White, rounded corners, shadow +- Max Width: `500-600px` +- Close button: `×` character + +--- + +## Implementation Guidelines + +### Architecture Requirements + +1. **Follow Existing Patterns**: + - Use `type` over `interface` (per COMPONENT_PATTERNS.md) + - No `any` types allowed + - Use Shadcn/ui components as foundation + - Maintain Server/Client Component separation + - Use React Query for all data fetching + +2. **File Organization**: + - Keep single-use components colocated with pages + - Reusable components go in `src/components/` + - Follow existing directory structure + +3. **Component Standards**: + - Loading states: Use `loading.tsx` with Skeleton components + - Error states: Use `error.tsx` with Error boundary + - Empty states: Use `EmptyState` component + - Forms: Use Shadcn Form components with validation + +4. **Data Fetching**: + - Use existing React Query hooks from `src/services/queries/` + - Create new query hooks if needed following same pattern + - Use API service layer from `src/services/api/` + +--- + +## Step-by-Step Implementation Plan + +### Phase 1: Global Changes +1. Update branding from "vTeam" to "Ambient Code Platform" +2. Update navigation component with user dropdown +3. Change "Projects" terminology to "Workspaces" everywhere +4. Update color scheme to match prototype + +### Phase 2: Workspaces List Page +1. Update page title and description +2. Modify table columns to match prototype +3. Add "Sessions" column with running count +4. Update create workspace modal +5. Style improvements to match prototype + +### Phase 3: Workspace Detail Page +1. Restructure layout with sidebar navigation +2. Implement tabbed interface (Sessions/Sharing/Settings) +3. Update breadcrumbs format +4. Move content to appropriate tabs + +### Phase 4: Sessions Management +1. Create session configuration modal component +2. Add model selection dropdown +3. Implement advanced settings accordion +4. Add BYOK (Bring Your Own Key) section +5. Update session creation flow + +### Phase 5: Settings & Permissions +1. Rename "Permissions" to "Sharing" +2. Restructure settings page with multiple cards +3. Add Runner Secrets configuration +4. Add Resource Limits section +5. Move API Keys to settings page + +### Phase 6: Polish & Testing +1. Fine-tune spacing and colors +2. Verify all interactions work +3. Test responsive behavior +4. Ensure accessibility standards +5. Validate with design guidelines + +--- + +## Critical Requirements + +### DO: +✅ Use Shadcn/ui components exclusively +✅ Follow DESIGN_GUIDELINES.md strictly +✅ Maintain TypeScript strict typing (no `any`) +✅ Use React Query for data fetching +✅ Implement proper loading/error states +✅ Use Tailwind CSS classes +✅ Keep existing API integration working +✅ Preserve functionality while updating UI +✅ Use semantic HTML +✅ Ensure accessibility (ARIA labels, keyboard navigation) + +### DON'T: +❌ Create custom UI components from scratch +❌ Use `any` types +❌ Break existing API integrations +❌ Remove error handling +❌ Ignore loading states +❌ Skip empty states +❌ Use inline styles (use Tailwind classes) +❌ Create new API endpoints (use existing backend) + +--- + +## Testing Checklist + +After implementation, verify: + +- [ ] All pages render without errors +- [ ] Branding updated throughout +- [ ] Terminology consistent ("Workspaces" not "Projects") +- [ ] User dropdown works in header +- [ ] Workspace list shows correct columns +- [ ] Session count displays properly +- [ ] Create workspace modal functions +- [ ] Workspace detail page has sidebar navigation +- [ ] Settings page has all sections +- [ ] Sharing page displays correctly +- [ ] Session creation modal works +- [ ] All forms validate properly +- [ ] Delete confirmations work +- [ ] Loading states display +- [ ] Error states display +- [ ] Empty states display +- [ ] Responsive design works +- [ ] Colors match prototype +- [ ] Typography matches prototype +- [ ] Icons display correctly +- [ ] Badges styled correctly +- [ ] Tables styled correctly +- [ ] Buttons work and are styled correctly + +--- + +## Reference Files + +### Must Read Before Starting: +1. `/Users/abraren/acorn/local/code/vTeam/components/frontend/DESIGN_GUIDELINES.md` +2. `/Users/abraren/acorn/local/code/vTeam/components/frontend/COMPONENT_PATTERNS.md` +3. `/Users/abraren/acorn/local/code/vTeam/static-prototype/README.md` + +### Key Prototype Files: +- `/Users/abraren/acorn/local/code/vTeam/static-prototype/index.html` - Workspaces list +- `/Users/abraren/acorn/local/code/vTeam/static-prototype/styles.css` - Design system +- `/Users/abraren/acorn/local/code/vTeam/static-prototype/projects/sample-workspace/page.html` - Workspace detail +- `/Users/abraren/acorn/local/code/vTeam/static-prototype/projects/sample-workspace/sessions/page.html` - Sessions list + +### Current Frontend Structure: +``` +components/frontend/src/ +├── app/ +│ ├── projects/ +│ │ ├── page.tsx # Main workspaces list +│ │ ├── new/page.tsx # Create workspace +│ │ └── [name]/ +│ │ ├── page.tsx # Workspace detail +│ │ ├── layout.tsx # Workspace layout +│ │ ├── sessions/page.tsx # Sessions list +│ │ ├── permissions/page.tsx # Permissions (→ Sharing) +│ │ └── settings/page.tsx # Settings +├── components/ +│ ├── ui/ # Shadcn components +│ ├── navigation.tsx # Header navigation +│ ├── page-header.tsx # Page headers +│ ├── breadcrumbs.tsx # Breadcrumbs +│ └── ... # Other components +├── services/ +│ ├── api/ # API client layer +│ └── queries/ # React Query hooks +└── types/ # TypeScript types +``` + +--- + +## Success Criteria + +The implementation is complete when: + +1. **Visual Consistency**: Frontend UI matches static prototype design +2. **Terminology**: All "Projects" references changed to "Workspaces" +3. **Branding**: "Ambient Code Platform" used throughout +4. **Functionality**: All existing features work with new UI +5. **Code Quality**: Follows all guidelines in DESIGN_GUIDELINES.md +6. **Type Safety**: No TypeScript errors, no `any` types +7. **User Experience**: Smooth interactions, proper loading/error states +8. **Responsive**: Works on desktop and mobile +9. **Accessible**: Keyboard navigation, ARIA labels, semantic HTML + +--- + +## Questions to Consider + +Before starting, review: +- What existing API endpoints are available? (Check `src/services/api/`) +- What data types are defined? (Check `src/types/`) +- What React Query hooks exist? (Check `src/services/queries/`) +- What Shadcn components are installed? (Check `src/components/ui/`) +- What's the current routing structure? (Check `src/app/`) + +--- + +## Getting Started + +1. **Read the design guidelines**: Start with DESIGN_GUIDELINES.md and COMPONENT_PATTERNS.md +2. **Explore the prototype**: Open static-prototype/index.html in a browser +3. **Review current frontend**: Familiarize yourself with the existing structure +4. **Plan your approach**: Break down work into small, testable changes +5. **Test incrementally**: Verify each change before moving to the next +6. **Commit frequently**: Make atomic commits for easy rollback + +--- + +## Additional Resources + +- **Shadcn/ui Docs**: https://ui.shadcn.com/ +- **Next.js App Router**: https://nextjs.org/docs/app +- **React Query**: https://tanstack.com/query/latest +- **Tailwind CSS**: https://tailwindcss.com/docs + +--- + +Good luck! Remember: **Preserve functionality while updating the UI** - this is a visual refresh, not a rewrite. + diff --git a/static-prototype/README.md b/static-prototype/README.md new file mode 100644 index 000000000..47c72bbe0 --- /dev/null +++ b/static-prototype/README.md @@ -0,0 +1,95 @@ +# vTeam Static HTML Prototype + +This directory contains a static HTML prototype of the vTeam user interface with dummy data. The prototype mirrors the actual application's sitemap and functionality for design and testing purposes. + +## 🗂️ Site Structure + +``` +static-prototype/ +├── index.html # Projects listing page +├── styles.css # Global styles +├── projects/ +│ ├── new/ +│ │ └── page.html # Create new project +│ └── sample-project/ +│ ├── page.html # Project overview +│ ├── rfe/ +│ │ └── page.html # RFE Workspaces +│ ├── sessions/ +│ │ └── page.html # Agentic Sessions +│ ├── keys/ +│ │ └── page.html # API Keys +│ ├── permissions/ +│ │ └── page.html # User Permissions +│ └── settings/ +│ └── page.html # Project Settings +└── integrations/ + └── page.html # External Integrations +``` + +## 🎨 Features + +- **Responsive Design**: Works on desktop, tablet, and mobile devices +- **Modern UI**: Clean, professional interface with consistent styling +- **Dummy Data**: Realistic sample data for all sections +- **Interactive Elements**: Buttons, forms, and navigation (visual only) +- **Complete Sitemap**: Mirrors the actual vTeam application structure + +## 📱 Pages Included + +### Main Navigation +- **Projects** (`index.html`) - List of all projects +- **Integrations** (`integrations/page.html`) - External service connections + +### Project Pages +- **Project Overview** - Dashboard with stats and recent activity +- **RFE Workspaces** - Request for Enhancement workspaces +- **Agentic Sessions** - AI-powered coding sessions +- **API Keys** - Authentication key management +- **Permissions** - User and team access control +- **Settings** - Project configuration + +### Forms & Creation +- **New Project** - Project creation form +- **Permission Management** - User access forms +- **Integration Settings** - Service configuration + +## 🚀 Usage + +1. **Open in Browser**: Simply open `index.html` in any modern web browser +2. **Navigate**: Click through the links to explore different sections +3. **Responsive Testing**: Resize browser window to test mobile layouts +4. **Design Review**: Use for UI/UX reviews and stakeholder demos + +## 🎯 Use Cases + +- **Design Reviews**: Share with stakeholders for UI feedback +- **User Testing**: Test navigation and information architecture +- **Development Reference**: Visual guide for implementing the real application +- **Documentation**: Screenshots and examples for documentation +- **Prototyping**: Quick iterations on design concepts + +## 📊 Sample Data + +The prototype includes realistic dummy data: +- 3 sample projects with different statuses +- Multiple RFE workspaces in various phases +- Agentic sessions with different completion states +- API keys with different permission levels +- User permissions with roles and groups +- Integration status for popular services + +## 🔧 Customization + +- **Styles**: Edit `styles.css` to modify colors, fonts, and layouts +- **Content**: Update HTML files to change sample data +- **Structure**: Add new pages following the existing pattern +- **Branding**: Replace logo and colors in the header section + +## 📝 Notes + +- All forms are visual only (no backend functionality) +- Links navigate between static HTML pages +- Responsive breakpoints at 768px for mobile +- Uses system fonts for better performance +- SVG icons for crisp display at all sizes diff --git a/static-prototype/design_path/prototype_version_1_feedback/Chat UI Feedback - 2025_10_30 15_56 EDT - Notes by Gemini.md b/static-prototype/design_path/prototype_version_1_feedback/Chat UI Feedback - 2025_10_30 15_56 EDT - Notes by Gemini.md new file mode 100644 index 000000000..1f68288a7 --- /dev/null +++ b/static-prototype/design_path/prototype_version_1_feedback/Chat UI Feedback - 2025_10_30 15_56 EDT - Notes by Gemini.md @@ -0,0 +1,55 @@ +Oct 30, 2025 + +## Chat UI Feedback + +Invited [Bob Gregor](mailto:bgregor@redhat.com) [Charles Thao](mailto:cthao@redhat.com) [Michael Clifford](mailto:mcliffor@redhat.com) [Ryan Cook](mailto:rcook@redhat.com) [Jeremy Eder](mailto:jeder@redhat.com) [Gage Krumbach](mailto:gkrumbac@redhat.com) [Sally O'Malley](mailto:somalley@redhat.com) [Dana Gutride](mailto:dgutride@redhat.com) [Andy Braren](mailto:abraren@redhat.com) [Daniel Warner](mailto:dawarner@redhat.com) [Yahav Manor](mailto:ymanor@redhat.com) + +Attachments [Chat UI Feedback](https://www.google.com/calendar/event?eid=MWdzaWtqZGxxNnJvajd1M3ZlN25lMG50cDcgZGF3YXJuZXJAcmVkaGF0LmNvbQ) + +Meeting records [Recording](https://drive.google.com/file/d/1DOhw6uHG1dA_oEZ9lZ8pBNp2YutiScbN/view?usp=drive_web) + +### Summary + +Participants Gage Krumbach, Dana Gutride, Daniel Warner, Michael Clifford, and Andy Braren discussed API keys, with Dana Gutride suggesting they be tabled until Jira phase two and hidden from the UI for the POC, while Gage Krumbach noted their benefit for user authentication with an MCP server. Daniel Warner detailed changes to project information, sharing features, and session creation, confirming that 'Project Info' will move to the overview page, and presented a core proposal for workflow driving using synced form-based and chat interfaces, which Gage Krumbach liked. The group debated the necessity of a spec repository, with Gage Krumbach suggesting use cases without persistence, and Daniel Warner agreed with Dana Gutride that users should be able to start at later workflow steps if a repository is partially completed. Daniel Warner and Gage Krumbach clarified the difference between the local PVC and remote repository representation, while Michael Clifford and Andy Braren discussed abstracting away the need for users to set up a spec repository by using a default 'umbrella repo' or organization-level agent definitions, which Daniel Warner agreed would provide a better onboarding experience. + +### Details + +* **API Keys and Jira Integration** Gage Krumbach mentioned that API keys were initially intended for external web hook usage, such as a Jira webhook, to communicate with the ambient back end and kick off jobs. Dana Gutride suggested tabling the discussion of API keys until Jira phase two, recommending hiding the feature from the UI for the Proof of Concept (POC) because the use case is currently confusing. Gage Krumbach added that the keys would be beneficial once they have an MCP server for user authentication. + +* **Project Information and Sharing Features** Daniel Warner noted that the "Sharing" feature, previously named "permissions," is mostly unchanged from the current version, though Peter was reportedly confused by the term "permissions". Daniel Warner plans to move "Project Info" back to the overview page to help orient users and confirmed that "Project Settings" remain unchanged. They also explained that the selection to create an interactive or a headless session has been moved out of the form and that they had collapsed some options to provide reasonable defaults and keep users moving. + +* **Session Creation and Workflow Driving** Daniel Warner presented a core proposal for driving the workflow using two methods: a form-based approach and a chat interface, both of which would remain synced. Gage Krumbach confirmed that they like the proposed workflow. Daniel Warner moved the 'add spec repository' feature to the top of the form workflow because it is a prerequisite for subsequent actions like creating an RF. + +* **Spec Repository and Persistence Requirement** Gage Krumbach questioned whether a spec repository is strictly required, suggesting use cases where a user might only want to run something without persistence, similar to running a workbench without PVC in Roy. Daniel Warner asked how an end user would determine if they need persistence, to which Gage Krumbach replied that the system could track unsaved changes and prompt the user to add a spec repository to save their work. Gage Krumbach also mentioned future possibilities, such as a UX workflow that interacts only with a Figma MCP server and does not require a spec repository. + +* **GitHub Integration and Repository Setup** Daniel Warner described the scenario where a user does not have the GitHub app connected and is asked to provide a personal access token to connect and define their spec repository. They highlighted that the chat feature is useful for keeping a log of the workflow and tracking progress, though they noted that the team might choose not to use system messages for every single move. The process requires the user to seed the repository to get started, after which they are ready to select agents. + +* **Agent Selection and Workflow Sequencing** Gage Krumbach confirmed that all agents are inherently available because they are using the cloud, and selecting one specifically prompts the system to use it. Daniel Warner presented the command-based design for workflows, and Gage Krumbach emphasized that spec workflows are "very order based," and the system will reject running steps out of order (e.g., running 'plan' before 'specify'). Dana Gutride pointed out that if a repository already has some steps completed, users should be able to start at a later step, which Daniel Warner agreed to incorporate, allowing users to drop in or out of the workflow. + +* **File Editing and Developer Experience** Gage Krumbach asked if files within the workspace are editable or read-only. Daniel Warner stated their opinion that files should not be editable within the system for this demo, suggesting users rely on integrated platforms like GitHub for editing as it is more developer-native. Dana Gutride stressed that the ability to edit files against the PBC on the repo, a feature requested by Jeremy, should not be discarded and should be evaluated in context later. + +* **Chat Interface and Verbosity Concerns** Daniel Warner explained the chat interface, which initially only offers a 'help' command until a workflow is selected, suggesting a default help mode to encourage user interaction and comfort with the system. Dana Gutride raised concerns about Claude's verbosity, which can be distracting in the chat. Gage Krumbach confirmed that they had already worked on hiding system messages with a debug mode option, and they can make tool calls look more curated. + +* **Chat Constraints and Collaboration** Gage Krumbach suggested that the main, workflow-connected session should be more constrained and opinionated, focusing on human actions, while an independent, collaborative session could offer more flexibility with Claude for file iteration. Daniel Warner acknowledged that exposing "raw Claude" would require a system around it, such as a help code prompt, to manage the conversation flow. The chat workflow demonstrates completing an RF by using commands and adding context, resulting in a copy or view option. + +* **Git Remote Connection and Repository Representation** Gage Krumbach questioned where the connection to the Git remote is, noting the separation between the local Git environment in the pod and the remote repository. Daniel Warner initially assumed the repository displayed was a reflection of the remote, but Gage Krumbach clarified that the session view represents the local PVC in the pod, whereas the workflow page represents the remote. Gage Krumbach argued that the GitHub relationship is crucial because it allows external users to pull down the experience, but noted that not all PMs or UXers want to use GitHub. + +* **Spec Repository Definition and Workflow Requirements** Daniel Warner maintained that connecting to the repo satisfies two requirements: storage and providing the location of the agents. Gage Krumbach suggested that a spec repository is an input type to the workflow, and some workflows, such as one only touching Jira or updating Google Docs, may not need to output or store anything in GitHub. Michael Clifford proposed baking the spec repository into a default 'umbrella repo' to abstract away the need for users to set it up, which would help simplify the experience and accommodate users uncomfortable with GitHub. + +* **Decoupling Agent Definitions and User Onboarding** Andy Braren and Michael Clifford discussed the idea of a higher entity (like a workspace or organization) managing agent definitions and configurations, eliminating the need for users to connect a repository in every new session. Daniel Warner liked the idea of zooming out to have organizations, which could be controlled at an admin level, providing a "batteries included" experience. Gage Krumbach noted that users like Anna often want to edit their templates and agents, supporting the need for a customizable, layered approach where users can own a fork of their workflow. + +* **Collaboration and Synchronous Collaboration** Gage Krumbach asked how other personas, such as UXers and PMs, would collaborate within the same workflow, which Daniel Warner admitted they had not accommodated in the current design. Gage Krumbach suggested that users collaborate by connecting to the artifact repository, which would act as the controller, while collaborators use a more generic chat session. Andy Braren acknowledged the challenge of synchronous collaboration, especially for PMs and UXers who prefer tools like Google Docs, and raised concerns about potential conflicts and drift if multiple people work on the same artifact. + +* **Next Steps and Face-to-Face Meeting** Daniel Warner announced a follow-up session the next day with Sally to gather more feedback and potentially iterate on the design before the face-to-face meeting, which officially starts on Tuesday. Daniel Warner outlined the plan for the face-to-face meeting: having Gage Krumbach focus on a hard engineering problem (like VLM or semantic router) while Daniel Warner leads the workstream on lower-hanging fruit like onboarding. + +### Suggested next steps + +- [ ] Dana Gutride will table the discussion on API keys for Jira phase two and hide API keys from the UI for the PC until the Jira integration is ready. +- [ ] Daniel Warner will move the current overview page back to the overview page. +- [ ] Daniel Warner will update the workflow steps to allow users to pick up at any point in the workflow based on the repository's current state and change the steps to status messages. +- [ ] Gage Krumbach will be on the work stream for the VLM/Semantic router. +- [ ] Daniel Warner and Charles Thao will lead the workstream for lower hanging fruit kind of onboarding next week at the face to face meeting. + +*You should review Gemini's notes to make sure they're accurate. [Get tips and learn how Gemini takes notes](https://support.google.com/meet/answer/14754931)* + +*Please provide feedback about using Gemini to take notes in a [short survey.](https://google.qualtrics.com/jfe/form/SV_9vK3UZEaIQKKE7A?confid=zH_mXZ8KObclka1X46BlDxIQOAIIigIgABgBCA&detailid=unspecified)* \ No newline at end of file diff --git a/static-prototype/design_path/prototype_version_1_feedback/Chat UI feedback session 2 - 2025_10_31 14_29 EDT - Notes by Gemini.md b/static-prototype/design_path/prototype_version_1_feedback/Chat UI feedback session 2 - 2025_10_31 14_29 EDT - Notes by Gemini.md new file mode 100644 index 000000000..610f2306c --- /dev/null +++ b/static-prototype/design_path/prototype_version_1_feedback/Chat UI feedback session 2 - 2025_10_31 14_29 EDT - Notes by Gemini.md @@ -0,0 +1,74 @@ +Oct 31, 2025 + +## Chat UI feedback session 2 + +Invited [Bill Murdock](mailto:bmurdock@redhat.com) [Charles Thao](mailto:cthao@redhat.com) [Ryan Cook](mailto:rcook@redhat.com) [Jeremy Eder](mailto:jeder@redhat.com) [Sally O'Malley](mailto:somalley@redhat.com) [Gage Krumbach](mailto:gkrumbac@redhat.com) [Yahav Manor](mailto:ymanor@redhat.com) [Dana Gutride](mailto:dgutride@redhat.com) [Andy Braren](mailto:abraren@redhat.com) [Daniel Warner](mailto:dawarner@redhat.com) ~~[Bob Gregor](mailto:bgregor@redhat.com)~~ ~~[Michael Clifford](mailto:mcliffor@redhat.com)~~ + +Attachments [Chat UI feedback session 2](https://www.google.com/calendar/event?eid=MzQyODZ1YThibWNyN2Y3cHFwOTJlbDkxNHEgZGF3YXJuZXJAcmVkaGF0LmNvbQ) + +Meeting records [Transcript](?tab=t.1kef0mivmirr) [Recording](https://drive.google.com/file/d/17OpqYKnDChJ3jIts70L6oC967pztWES_/view?usp=drive_web) + +### Summary + +Daniel Warner and Andy Braren discussed utilizing AI for prototype updates, leveraging Claude code to process feedback and generate changes, which Andy Braren aims to make easily accessible. Sally O'Malley reported external interest from IBM's Ana Sailor, which led to a discussion with Dana Gutride about the project's open-source nature and the need to manage its initial user experience while sharing the prototype, which Dana Gutride encouraged as a means to align on changing how people work in Red Hat. The participants, including Daniel Warner, Dana Gutride, and Bill Murdock, clarified IBM's Watsonx orchestration, and Daniel Warner presented multiple UI updates for the project and session views, including removing extraneous tabs and clarifying naming conventions, while Bill Murdock and Sally O'Malley raised concerns about confusing terminology like "headless session." The participants also discussed the necessity of a hosted platform for multi-agent swarm functionality and integrations with business systems, with Gage Krumbach and Daniel Warner noting the importance of a server for swarming and complex business integrations, and Gage Krumbach further detailing the technical hurdles in implementing the changes, particularly regarding Git integration and the shifting structure of the workflow and session pages. + +### Details + +* **Utilizing AI for Updates** Daniel Warner shared an experiment involving using Claude code to process feedback and meeting notes into a change set and plan for prototype updates. Andy Braren noted they are working to make this type of pipeline, which takes recordings and feedback to rapidly generate updates, easy for everyone. Gage Krumbach mentioned using the Slack MCP to identify stakeholders by reviewing the history ([00:01:01](?tab=t.1kef0mivmirr#heading=h.fmembd9qmred)). + +* **External Interest in the Prototype** Sally O'Malley reported that Ana Sailor, a distinguished engineer at IBM, was impressed with the work and asked to record a demonstration to share with their team for potential use. Sally O'Malley made clear that the project is early, open source, and has not yet been tested for code quality ([00:02:06](?tab=t.1kef0mivmirr#heading=h.56l1uydmiauq)). Dana Gutride commented that they would not stand in the way of excitement about the project becoming a movement, but emphasized the need to control the process and ensure a positive initial user experience ([00:04:58](?tab=t.1kef0mivmirr#heading=h.wpeg9w2j58g8)). + +* **IBM's Watsonx Orchestration** The discussion addressed IBM's agentic orchestration solutions, with Dana Gutride mentioning uncertainty about the Orchestrate solution being integrated with Watsonx. Daniel Warner confirmed that the Orchestrate project would be separate from other integrated pieces like document ingestion in the Watsonx platform, according to Danielle and Peter ([00:03:04](?tab=t.1kef0mivmirr#heading=h.w85rjpjedcfs)). Bill Murdock clarified that Watsonx is the name for all Watsonx products and that only Watsonx.ai is expected to be coming over ([00:04:06](?tab=t.1kef0mivmirr#heading=h.wyu90do789om)). + +* **Prototype Sharing and Goals** Daniel Warner sought confirmation on whether they could post a video of the prototype's functionality, which runs on the ambient code platform, to a large group like in UX. Dana Gutride encouraged sharing, stating that their goal is not to sell something but to change the way people work in Red Hat, and that excitement about the work will help align on what that looks like. Sally O'Malley noted that Ana Sailor was particularly impressed by the Git integration aspects ([00:05:45](?tab=t.1kef0mivmirr#heading=h.rvooapyx2krd)). + +* **Git Integration and Collaboration** Dana Gutride emphasized that using Git as the source of truth is crucial for keeping developers connected. Bill Murdock raised a concern about the friction introduced by pushing and pulling to Git for frequent iterations using Claude code ([00:06:53](?tab=t.1kef0mivmirr#heading=h.6pbssnt45dzw)). Dana Gutride agreed about the friction but suggested it is the same friction Git allows for team collaboration, noting that the project should allow for flexibility, from single use to team collaboration without being overly prescriptive ([00:07:50](?tab=t.1kef0mivmirr#heading=h.3bvgrh9xilb9)). + +* **Project Page UI Updates** Daniel Warner presented design updates for the project page, including minor visual changes and moving action items closer to the table they modify ([00:09:19](?tab=t.1kef0mivmirr#heading=h.pr0t1nxpnhc)). The most significant change was bringing the running status of projects up to the project page to function as a dashboard and direct attention. Daniel Warner also added default values for project name and display name to ease early user onboarding ([00:10:24](?tab=t.1kef0mivmirr#heading=h.sy5dian98oxv)). + +* **User Flow and Context Orientation** To maintain user context and orientation, Daniel Warner explained that after creating a new project, the user would remain on the projects page, and the new project would be added to the table, instead of immediately taking them to the project page. Bill Murdock questioned the need for both display name and project name, which Gage Krumbach clarified is a Kubernetes concept necessary for having an ID separate from the potentially non-unique display name ([00:11:22](?tab=t.1kef0mivmirr#heading=h.mds4yc87jtpz)). + +* **Project and Session View Changes** In the project page, sessions were made front and center to drive users to them ([00:12:17](?tab=t.1kef0mivmirr#heading=h.lhpr0v6t829j)). Daniel Warner planned to remove the project information tab and incorporate the details into the project header to better orient the user within the project. Additionally, Daniel Warner intended to remove the workflows tab to clean up the UI, as it created an extraneous second flow for getting into a session ([00:13:25](?tab=t.1kef0mivmirr#heading=h.aw4zrmoipge1)). + +* **API Keys and Workflows Management** The API keys section, which had caused early user confusion, was suggested to be put aside until a need for a third-party integration like Jira arises. Andy Braren clarified that while the initiation of a session from a workflows area may not be needed, there is still a need for a place to manage and add workflows available for a project, perhaps within project settings ([00:14:16](?tab=t.1kef0mivmirr#heading=h.ic6ltcudlsca)). + +* **Session Creation and Headless Sessions** Daniel Warner moved the choice between creating an interactive or a headless session into a selection menu instead of the form ([00:16:06](?tab=t.1kef0mivmirr#heading=h.b061fum683gv)). To ease onboarding, they collapsed fine-grain model control options into an advanced tab, as these options were adding noise to the view for early users ([00:17:01](?tab=t.1kef0mivmirr#heading=h.rewh79fmk1c)). Bill Murdock and Sally O'Malley raised concerns about the term "headless session" being confusing for new users ([00:17:52](?tab=t.1kef0mivmirr#heading=h.xlnyr5gel9c9)). Gage Krumbach suggested that everything will likely become interactive, with headless capabilities contained within a workflow, making the separate headless session concept unnecessary for initiation ([00:18:45](?tab=t.1kef0mivmirr#heading=h.tgehxhyg8pxi)). + +* **Interactive Session Interface** The interactive session includes a familiar chat interface and a form-based workflow sidebar that both remain synced. Daniel Warner noted that in the existing UI, a spec repository is required before most actions, so this is open by default ([00:19:36](?tab=t.1kef0mivmirr#heading=h.7x85vxi9imqu)). Daniel Warner explained that without a selected workflow, users only have generic session capabilities like chatting with Claude and using the help command ([00:20:43](?tab=t.1kef0mivmirr#heading=h.gzcen8rydbgm)). + +* **Spec Repository Setup** The current design requires the user to enter their GitHub name and a personal access token to connect and select their spec repository if they haven't been set up by an admin. Sally O'Malley suggested adding a popup description to educate users on what a spec repo is. Bill Murdock proposed handling the repo request through the chat, allowing the bot to intelligently guide the user ([00:21:43](?tab=t.1kef0mivmirr#heading=h.qbl3qx8n6y5s)). + +* **Agent Selection and Behavior** The chat interface shows the progress log and can guide the user through the setup process ([00:22:38](?tab=t.1kef0mivmirr#heading=h.9yzx9eo0rfh8)). After seeding the repository, users can select agents. Daniel Warner noted that if no agents are selected, Claude automatically picks agents based on the user's request, a feature Gage Krumbach confirmed ([00:23:38](?tab=t.1kef0mivmirr#heading=h.nj1hqfws8vf3)). Dana Gutride suggested hardcoding this auto-selection behavior and including an info button to educate users that it is happening ([00:24:42](?tab=t.1kef0mivmirr#heading=h.gcu5unaud168)). + +* **RF and Spec Kit Workflow Naming** Bill Murdock questioned the initial step of the "create RF workflow," which first creates an RF.md and then a spec.md ([00:25:53](?tab=t.1kef0mivmirr#heading=h.quug5sev6xg5)). Sally O'Malley suggested renaming RF.md to Idea.md ([00:26:46](?tab=t.1kef0mivmirr#heading=h.a8ebdew4o2pz)). Dana Gutride noted that RF (Request for Feature) is an organizational standard for Product Managers (PMs), while specification (Spec) is needed for engineering ([00:27:42](?tab=t.1kef0mivmirr#heading=h.kg0xq3ra3ye1)). The consensus was that PMs should focus on iterating on the idea/RF, and that there is a need to distinguish the RF workflow from the specification process for developers ([00:29:38](?tab=t.1kef0mivmirr#heading=h.rb1f2bqrltsy)). + +* **Workflow Customization and User Types** Gage Krumbach emphasized that there are two types of users: power users who run specific commands, and "workflow runners," such as PMs, who should be taken through a guided journey by the platform ([00:33:45](?tab=t.1kef0mivmirr#heading=h.1f96jkltiqdu)). The broader consensus shifted towards the need for a generic platform where users can define and run whatever workflows they desire, with the current create RF workflow serving as an illustrative example ([00:37:06](?tab=t.1kef0mivmirr#heading=h.hucdv8eoywsg)) ([00:39:05](?tab=t.1kef0mivmirr#heading=h.c4r1zvi0t45x)). + +* **Artifact Interaction and Iteration** Daniel Warner confirmed that when a file artifact is created in the current design, it opens in a new window, which could be the GitHub editor, for manual editing. Bill Murdock expressed a preference for interactive iteration on the artifact within the session, rather than manual editing ([00:41:09](?tab=t.1kef0mivmirr#heading=h.3nzhtajabw6q)) ([00:42:57](?tab=t.1kef0mivmirr#heading=h.7tejs9nhzkgb)). Sally O'Malley clarified that iterating on the artifact is possible through the chat interface while the session is alive ([00:43:43](?tab=t.1kef0mivmirr#heading=h.ukbjutwrcfxv)). + +* **Local vs. Hosted Platform** Bill Murdock expressed a desire for a local, blank slate redesign ([00:45:36](?tab=t.1kef0mivmirr#heading=h.f3idc0zd7flm)). Gage Krumbach argued that a hosted agent or workflow service is necessary, especially because PMs do not use tools like Cursor, and for the swarm use case which involves collaboration and context switching across multiple projects ([00:46:28](?tab=t.1kef0mivmirr#heading=h.hjml4z5xd57v)) ([00:50:13](?tab=t.1kef0mivmirr#heading=h.lmbtrlmi1yjl)). Andy Braren agreed that local use cases, potentially to handle personal context or privacy, have a place, and that lighter local setups, possibly using Kind clusters instead of CRC, are being pursued ([00:47:28](?tab=t.1kef0mivmirr#heading=h.sneigyjr3dat)). + +* **Multi-Agent Swarm and Business Integrations** Gage Krumbach highlighted that the swarming aspect, where multiple agents and users collaborate on a flow, is a main end goal, which is why a server is required ([00:49:15](?tab=t.1kef0mivmirr#heading=h.xooxulpi5wge)). Daniel Warner emphasized that the multi-agent setup and necessary integrations with business systems like Jira contribute to the necessity of a hosted solution that lives on a cluster ([00:54:04](?tab=t.1kef0mivmirr#heading=h.cqui21mxifc9)). + +* **Future of Workspaces and Platform Development** Andy Braren suggested that collaboration on artifacts and easier context switching via an agentic inbox or tabs are future augmentations ([00:52:21](?tab=t.1kef0mivmirr#heading=h.zhyhrazem56h)). The need for another level of organizational hierarchy, like a "workspace" or " team," was also suggested for PMs to collectively manage their workflows ([00:52:59](?tab=t.1kef0mivmirr#heading=h.4lcg4vl6rof3)). Andy Braren and Sally O'Malley agreed to aim to implement the current design in the next week, suggesting an accelerated path forward for the prototype's real components ([00:57:28](?tab=t.1kef0mivmirr#heading=h.7her7idmbsuv)). + +* **Upcoming Project Structure and Travel Plans** Sally O'Malley confirmed that the team will be present on Monday, though Gage Krumbach mentioned they would be traveling for half of the day and working on the plane. Daniel Warner shared their impression from a conversation with Bob that the team would be split into different projects, with a core group including Daniel Warner, Andy Braren, and Bob likely working on a specific project ([00:57:28](?tab=t.1kef0mivmirr#heading=h.7her7idmbsuv)). Gage Krumbach identified multiple workstreams, including one focused on the UX flow and another, "bring your own plugin," that Michael and Daniel Warner are involved in ([00:58:22](?tab=t.1kef0mivmirr#heading=h.pt6bg3neq2ot)). + +* **Technical Changes and Frontend Work** When Sally O'Malley asked if the changes to achieve Daniel Warner's demo were mostly front-end, Gage Krumbach explained that there is a fundamental technical challenge because the "workflow page" has been removed and merged into "session pages," requiring bridging the technical gap between the GitHub remote representation and the workspace representation. Gage Krumbach noted that while they hope to avoid visual changes, resolving the underlying technical complexity is the biggest task, alongside quick fixes and more fundamental changes ([00:59:31](?tab=t.1kef0mivmirr#heading=h.1c0ri5rr58iq)). Daniel Warner asked the team if they preferred a fork or push access to share the branch with the static prototype demo, and Sally O'Malley and Gage Krumbach indicated that a fork branch should be fine, but Sally O'Malley also suggested pushing to the main branch ([01:00:36](?tab=t.1kef0mivmirr#heading=h.ruumis91jypr)). + +* **AI-Assisted Code Implementation** The team discussed using an AI model to implement the static HTML prototype into the existing codebase. Andy Braren suggested trying this approach next week if the APIs are available, which Gage Krumbach thought would be successful ([01:01:34](?tab=t.1kef0mivmirr#heading=h.kcn9qtdokczq)). Sally O'Malley questioned if Opus is the best model for this, to which Gage Krumbach suggested that any max model would do fine and that better prompting is more critical than a bigger model. Daniel Warner was highly optimistic about this approach if the work was broken up, especially since the front-end framework (shad CN or similar) seems straightforward and compatible with Claude ([01:02:19](?tab=t.1kef0mivmirr#heading=h.ibij613pn9h)). + +* **Fundamental Technical Hurdles for Implementation** Gage Krumbach expressed the need to whiteboard complex inner workings because of two key challenges: the pod spin-up time and the Git integration. They noted that the current demo leans towards a constantly running cloud code session, which fundamentally changes things, and the necessary Git integration is not currently present and requires careful work to avoid losing features. The speakers concluded the main portion of the meeting, with Gage Krumbach, Daniel Warner, and Bill Murdock exchanging thanks ([01:03:17](?tab=t.1kef0mivmirr#heading=h.dbpzl365c3zr)). + +### Suggested next steps + +- [ ] Daniel Warner will send the video later today or write it up in Slack about the cool experiment taking feedback and meeting notes to have Claude code munch it into a change set and a plan. +- [ ] Daniel Warner will work on a second prototype, using existing work, based on the discussion, and aim to have it ready for next week's meeting. +- [ ] Daniel Warner will run the plan to update the prototype and record the progress. +- [ ] Gage Krumbach will share the document related to the workstreams. +- [ ] Daniel Warner will make his branch with the prototype available by pushing a branch to the main project. +- [ ] Andy Braren, Gage Krumbach, Sally O'Malley, and Daniel Warner will try next week to use Claude to compare the code bases and figure out the implementation using the available APIs. + +*You should review Gemini's notes to make sure they're accurate. [Get tips and learn how Gemini takes notes](https://support.google.com/meet/answer/14754931)* + +*Please provide feedback about using Gemini to take notes in a [short survey.](https://google.qualtrics.com/jfe/form/SV_9vK3UZEaIQKKE7A?confid=G25WoVgp4zGUAB4vwFWNDxITOAIIigIgABgBCA&detailid=unspecified)* \ No newline at end of file diff --git a/static-prototype/design_path/prototype_version_1_feedback/Chat UI feedback session 2 - 2025_10_31 14_29 EDT - transcript.md b/static-prototype/design_path/prototype_version_1_feedback/Chat UI feedback session 2 - 2025_10_31 14_29 EDT - transcript.md new file mode 100644 index 000000000..d79f2bd17 --- /dev/null +++ b/static-prototype/design_path/prototype_version_1_feedback/Chat UI feedback session 2 - 2025_10_31 14_29 EDT - transcript.md @@ -0,0 +1,856 @@ +Oct 31, 2025 + +## Chat UI feedback session 2 \- Transcript + +### 00:00:00 + +  +**Daniel Warner:** so good. Oh my gosh, I look like um in the afterlife over here. +**Andy Braren:** speaking to us from the end. Yeah. +**Daniel Warner:** There we go. I think that's better. +**Andy Braren:** Nice. +**Daniel Warner:** I've got a I've got a cool experiment going now. I'll I'll send you the video later today, Andy. Actually, I'll send it to everybody or I'll just write it up in Slack, which is like taking all this feedback and the meeting notes and having Claude code munch it into a change set and then a plan. +**Andy Braren:** Sweet. +**Daniel Warner:** And I haven't I haven't let it rip yet to to update the prototype because I wanted to make sure Sally got her two cents in before we do that. But um but I have high hopes. +**Andy Braren:** Awesome. +**Daniel Warner:** Yeah. +**Andy Braren:** Trying to do the same and make that an easy pipeline for everyone because we're doing that for mass and stuff too. Just grab the recordings, take the feedback, turn into rapid updates. It's awesome. +**Daniel Warner:** Yeah, that's awesome. +  +  + +### 00:01:01 + +  +**Gage Krumbach:** I've been doing that with the Slack MCP. I just did one now where I looked at all our history identifying the stakeholders. It just completed like an hour ago. +**Daniel Warner:** Yeah, I gota I got to hook up that Slack MCP. +**Gage Krumbach:** It's cool. +**Daniel Warner:** I tried a while ago and that we didn't have permissions to do it, but Which +**Gage Krumbach:** Yeah, you have to do it kind of key way, but do what you got to do. +**Andy Braren:** Yeah, thanks for passing that along, Gage. I haven't tried it yet, but yeah, sounds good. It's still not official. Like, it still requires uh yeah, doing something in dev tools and using the web version. +**Gage Krumbach:** Yeah, I talked to someone from Slack and they said the official one won't be until uh 2026, sometime mid 2026\. So, +**Sally O'Malley:** Hey. +**Andy Braren:** Yeah. +**Daniel Warner:** Hey, Sally. +**Sally O'Malley:** Hi. Um, before we get started, can I mention something? I I know. +**Daniel Warner:** This is a very very structured meeting. +**Sally O'Malley:** I'm like, of course, I'm going to I um I just got off a call once a month. +  +  + +### 00:02:06 + +  +**Sally O'Malley:** I meet with Ana Sailor. She is in IBM. Uh she's a distinguished engineer in IBM, but we just met at at Summit one year. +**Dana Gutride:** We're not +**Sally O'Malley:** And so, um Dana, this is going to be pertinent to you, too. I just got off a call with my friend, her name's Ana Sailor, and uh she's a distinguished engineer at IBM and uh she works on all things agents and policy and Oscale and um security. And anyways, um I was showing her what I've been working on and she was blown away and she made me stop so that she could record it and I'm hoping this is okay with you. +**Daniel Warner:** Beautiful. +**Sally O'Malley:** Is it? And then she wants to show it to her team and she wants them to start using it. This this just just happened. I did not mean for this to happen. I just have to and I told her that we only use it for open source. It's so early. I'm like we haven't tested how good the code is or anything like so yeah that happened. +  +  + +### 00:03:04 + +  +**Sally O'Malley:** Just wanted to let you know. +**Dana Gutride:** All right. +**Sally O'Malley:** I I told her like Yeah. Yeah. +**Dana Gutride:** Yeah, I mean IBM has I I know their orchestrate solution is not coming over with Watson X from what I've heard. So it's not clear and Daniel maybe you've actually Bill and Daniel maybe you've heard more. So like the agentic orchestration that IBM has I haven't heard any information on that that coming over as part of the uh you know what's coming back. +**Daniel Warner:** Yeah. No, I asked about that explicitly and um Watson the the orchestrate project is going to be separate from the other pieces that they're trying to integrate now with the like document ingestion and all that. Um I can't remember what what the name of that Watsonx platform is. Might just be Watsonx. Um that's separate from orchestrate. At least that's what Danielle said and what Peter said. +**Dana Gutride:** Yeah. +**Bill Murdock:** No, Watson X is the name for everything together like all the Watsonx products. So, it couldn't be Watson X, but I don't know what you're talking about either. +  +  + +### 00:04:06 + +  +**Daniel Warner:** Orchestrate not coming over. +**Bill Murdock:** Sorry. +**Daniel Warner:** Yeah. +**Bill Murdock:** Orchestra is not coming over, but I think lots of other Watsonx stuff isn't coming over either. +**Daniel Warner:** Yeah. +**Sally O'Malley:** What? +**Bill Murdock:** Like Watsonx data, Watsonx gov. I don't think it's coming over. As far as I know, it's just Watsonx.ai. +**Sally O'Malley:** Do you want me to have her reach out to you before she shows it to her team? +**Dana Gutride:** I don't care. I mean, we just can't make it available right now because of like all the cloud stuff, right? Like, we're just we're too dependent on I think I think we would love to have other people pick it up, right? +**Sally O'Malley:** That's what I told I told her. Yeah. And but like I think she was thinking they would just run it themselves. I mean it is an open-source project right. +**Dana Gutride:** This this is a weird time because if we move this like I I mean Jeremy and I like we'll probably talk, but there's this thing that happens when people get excited about something and you can't stop it when it becomes a movement. +  +  + +### 00:04:58 + +  +**Sally O'Malley:** Okay. Okay. +**Dana Gutride:** So, I'm not going to get in the way and I think we would be it would be a mistake to stop it, but like trying to control it is really difficult, but we need to make sure that we don't lose people at the same time, which is why I've been like on this discipline kick with with us. +**Sally O'Malley:** Yeah. +**Dana Gutride:** So, yeah, I don't want to get in the way, right? +**Sally O'Malley:** Mhm. +**Dana Gutride:** This is why we're trying to do it in the open, but we've got to figure out like like let's get that that first five minutes of using this to be like heavenly, right? And then Yeah. +**Sally O'Malley:** Yep. I told Yeah. I told her. Yeah. Yeah. All right. +**Dana Gutride:** But yeah, that's cool. +**Sally O'Malley:** Cool. I I think it's it's totally fine. +**Daniel Warner:** All right. +**Sally O'Malley:** Yep. +**Daniel Warner:** I actually have a I have a related question for you then, Dana, which is so I took the the feedback that we that I've gotten on this prototype from Slack and from the session yesterday and sort of used Claude code to munchge it into a plan. +  +  + +### 00:05:45 + +  +**Daniel Warner:** Um, and I'm going to just run the plan. Um, and I'm recording my progress as I go because I thought that it would be of interest to several groups. Is it is it a problem for me to because I go through some of the functionality in this in on ambient code platform. Is it a problem if I post that to a large group like in UX or should I No. Okay. +**Dana Gutride:** No, we we are like we want to lead or at least facilitate the way where other people can use this as much as possible, you know. Yeah. I I think that's this is like our goal is not to build like not to sell something that everyone loves, right? Our goal is to change the way people work in Red Hat, right? And and if people are excited about what we're doing, then that's going to help us align on what that looks like. Right? This is just a means like a fun way of getting there. +**Sally O'Malley:** She was Yeah, she was blown away by things I didn't even think she like I didn't I as she was getting excited about I was like wow this is really cool like all of the git stuff all of the git integration and like it's just uh we've yeah we have a lot going on in this project but um yes +  +  + +### 00:06:53 + +  +**Dana Gutride:** Yeah. Yeah. Git is like that's why I Jira like Yeah, we'll get there. I don't I don't personally care about Jira, but but having Git as a source source of truth is going to be the thing that keeps developers connected. +**Sally O'Malley:** do you see my checklist in Jira. Did you look at it? +**Dana Gutride:** Yeah, I saw you. I s +**Sally O'Malley:** It's amazing. But I did fail gave G after this meeting. We'll let's stay on and like get your PR merge. +**Gage Krumbach:** Yeah. +**Sally O'Malley:** All right. +**Bill Murdock:** I I mean get stuff has pros and cons though because like it it's really nice if you're just using clawed code to be able to like make a change, test it, make a change, test it, make a change, +**Daniel Warner:** All right. So, +**Bill Murdock:** test it, make a change, test it. If you have to push it to get and pull it from git every time, that's that's friction. +**Dana Gutride:** Oh yeah, I agree. I but I think the friction is the same friction that git allows for with a team, right? +  +  + +### 00:07:50 + +  +**Dana Gutride:** As soon as you need to collaborate with other people, you need get in the room, right? If you're but but when you don't build like there's no friction requirement. If you just want to use spec locally, then then that's fine. But I I think like it it allows however engaged as you need to be from like single all the way through. And I don't think we need to be prescriptive in that. I think teams will pick it up and use it the way they they organize. +**Bill Murdock:** Yeah, I'm just saying that it'd be nice if there was a way to be have an integrated both where you can you can iterate locally as much as you want and then automatically push it to get with one click or something like that. +**Dana Gutride:** Yeah, I think a Yeah, but that makes that's not that's not going to be hard to do. +**Bill Murdock:** Um, I don't know how we get there yet. +**Dana Gutride:** Just the same way like sometimes you do a git and init locally and you start with your own git repo and then you don't even have a repository on GitHub yet until you're ready or sometimes you start with a repo and then like I think that that flow will work for us. +  +  + +### 00:08:43 + +  +**Dana Gutride:** We're not going to be Yeah, we'll work through that. +**Bill Murdock:** Yeah, but I think it's a little hard because like Ambient Code Platform is running out on a cloud somewhere and it's got to push all the stuff back to your local hard drive, I guess, to um Yeah, sounds +**Daniel Warner:** Cool. +**Dana Gutride:** I think that's that's a good one to work on. +**Bill Murdock:** good. +**Sally O'Malley:** I don't know. +**Daniel Warner:** So, I will just I'll walk through the flow. Um, and you guys can just offer up feedback. I don't know, Bill and Sally if you guys if you watch the video, but I think it's helpful. +**Bill Murdock:** I I watched I watched the video but I did not watch the recording of yesterday's session. +**Daniel Warner:** Yeah. +**Bill Murdock:** I didn't have time for that. Sorry. +**Daniel Warner:** Okay. I'll I'll point out what's going to change. I'm I'm doing the thing that irritates me, which is presenting designs where we already have feedback on it, but I wanted before I made any changes, I wanted to make sure everybody felt like, you know, everyone got ample +  +  + +### 00:09:19 + +  +**Bill Murdock:** Sounds good. +**Daniel Warner:** opportunity to chime in. Yep. +**Bill Murdock:** Yeah, I felt like I had a bunch of changes, but hopefully they're already in. So, so you'll go over them as you go. That sounds +**Daniel Warner:** All right. Cool. So, um, so this is the projects page. Um, not much has changed on this page. uh reorganize a things a little or not reorganize but just clean things up a little bit, added in some dividers, visual changes, that type of stuff. But it's the same just like super basic theme. Um the integrations um tab or navigation item I pulled out of the the user menu, but Gage has already had some feedback on that um that that it doesn't really make sense for it to be there. we got to move it back into the the user menu to sort of like reinforce the idea that it's like scoped to users. Um the action items I just brought them down a little bit closer to the table that they modify um as opposed to having them up here in sort of like more of a global space. +  +  + +### 00:10:24 + +  +**Daniel Warner:** Um, and the I guess the the most major change here is I brought the running status for projects that have running sessions in them um up to the projects page just so that it could function a little bit more like a dashboard and give people an insight into like what they may more urgently need to look at because it's it's running or or it's in process. So don't even know if that's possible, but I think it would be helpful um in just in terms of like directing attention. So in this case like uh you can create a new project. Um one small usability upgrade but I think an important one is just putting in default values for the project name and and display name. Um this is like this is just for early users for ease of onboarding that type of stuff. I watched two sessions in a row where the person like had to take multiple runs at this forum in order to get it going. So I figure two clicks to create a project and we're off to the races. +  +  + +### 00:11:22 + +  +**Daniel Warner:** Um, so instead of taking you directly to the project page, which is what happens now in the UI, we stay on this page. Um, and and the new project is is added to the table. Um, I did that because for the same reason those same two sessions there, the people were like scrolling around. They were trying to parse sort of like where they were. um it wasn't evident to them that they had entered into a project um or that they had entered into a session for that matter. So um just trying to help the user keep context and keep them oriented. So create a new project and then if you want to go and look at a project you just click on it same as you do now. +**Bill Murdock:** Do we really need Sorry to interrupt, but do we really need both display name and project name? +**Daniel Warner:** Um, so yeah, it's a pattern that ex +**Bill Murdock:** I'm not sure I understand why we have one of each. +**Gage Krumbach:** It's a Kubernetes thing. So if you people want to see the Kubernetes name, it's the ID. +  +  + +### 00:12:17 + +  +**Gage Krumbach:** So you can have things that have the same display name. So it's good to have the ID. +**Bill Murdock:** Okay, I guess fair. +**Daniel Warner:** that exists on everything that I've worked so far at Red Hat, which I've not been here long, but the projects that I've been on all involve that. And I assume that it is just what Gage said, which is like it's specific to like Kubernetes-based projects and probably has like value in terms of like the admin or setup or whatever. Um anyway, so now you're on the project page and not a ton has changed here. um the the sessions have been sort of like put front and center um because from seeing the the onboarding that people are going through like we're really trying to drive them to a session. So I wanted to make that more prominent in the project view. So here we are on the projects view and the sessions are front and center. Um, now you know, Gage's initial feedback, I know you kind of walked it back, but I I think it I think your first impression was right, which is like it's not immediately apparent here that I'm at the project level. +  +  + +### 00:13:25 + +  +**Daniel Warner:** So, I think um what I'm going to do is and like Jeremy had suggested in Slack to um just ditch this product in project information tab and I'm just going to bring some of this information into the project header to make it make it sort of like really say okay you're in a project. um the workflows tab. Uh Dana suggested yesterday just pulling this out um because it sort of it creates sort of a second flow for getting into a session and it just feels extraneous at this point. So I think to clean things up, we'll probably remove the workflows tab as well. +**Bill Murdock:** So what hap So how do you get into a a session? +**Daniel Warner:** Uh we'll get into that. +**Bill Murdock:** You just go into sessions. Okay, cool. Sorry. +**Daniel Warner:** No, no, no. I I'll get there. I'm just walking through this Right. +**Bill Murdock:** This is just a different way to get into sessions is going away. It's not you're going to get there. Okay, cool. +  +  + +### 00:14:16 + +  +**Daniel Warner:** Right. Um and so API keys, uh this caused a little bit of confusion with some of the early users and yesterday, um I can't remember who suggested it, but basically saying like until we have like a full-fledged Jira integration or some other thirdparty integration, we don't really need this API key se uh section. So we can like put it to the side and then once we have something to offer people like okay give Jira you know an API key so that it can access this workflow um then then we'll add it back in. Yeah, Bill. +**Bill Murdock:** Uh, I guess I was just confused by what it's trying to do. +**Daniel Warner:** Yeah, Andy. +**Andy Braren:** Yeah, one clarification work on your workflows point. I remember that discussion from yesterday. I think Danny, your point, we also discussed like moving that workflows area or something and making it like a workflow management area potentially. Um maybe it's within project settings or whatever, but like having some place to manage and add or whatever the workflows that are available to you inside this particular project is probably still a need, but the need for initiation +  +  + +### 00:15:09 + +  +**Dana Gutride:** Yeah, I think so. +**Andy Braren:** from that workflows area probably isn't needed. I think that's what we Yeah. +**Daniel Warner:** Okay. +**Bill Murdock:** Do we really need separate concept of workflow in session? I don't know. Maybe. Yeah, I guess. +**Daniel Warner:** Yeah. +**Dana Gutride:** Yeah, these are like the core things other teams will bring to do their to do their type of work, which we're hearing a lot of request for those already. +**Gage Krumbach:** Yeah. +**Sally O'Malley:** What do you think about calling it like a generic session versus a workflow? Like because a workflow is a more structured session. So, but you said you you're going to move the workflows into the sessions. You're going to walk through that part. +**Daniel Warner:** Yeah. Yeah. I I am. +**Sally O'Malley:** Okay. +**Daniel Warner:** So, I'll just I'll cover one more thing and then we'll we'll get into the sessions here, which is sharing. This used to be called permissions. Now, it's called sharing. Just to try and clarify what that is. +  +  + +### 00:16:06 + +  +**Daniel Warner:** Um, nothing else has changed in this view. Yeah. page. +**Gage Krumbach:** Uh, sorry it was on the workflow stuff. If we come back to it, we can talk about it. +**Daniel Warner:** All right. So, here's where here's where you land. Sessions are front and center. Um, you can click into a session by clicking on any one of these or you can create a new session similar to the way that you can do now, except I moved the choice of creating an interactive session or a headless session into this into the select instead of the form. So if you choose interactive session, it follows the same pattern as creating a project which is um you just sort of like have reasonable defaults here and you can choose to create a session and it creates it in the table. It doesn't take you strictly straight to the session view. Um also uh I did collapse a lot of the options around like fine grain model control into like an advanced tab type of situation. +  +  + +### 00:17:01 + +  +**Daniel Warner:** Um, this is really just to to ease onboarding. You know, I didn't want to like remove any of the functionality. I just um the these things are like were not even addressed by the early users and they just kind of were adding noise to the view. So, I I just wrapped them up for now. So, you create a session. Uh, okay. We got hands up here. Sorry. Like my like it's really hard for me to see the chat window. So, also feel free to just cut me off and chime in, but +**Bill Murdock:** Yeah, sounds good. Sally's first. +**Sally O'Malley:** Okay. So, uh um what I'm what I'm worried about, first of all, like this is awesome and you're like clearly a UX expert. So, um but what I'm concerned about is that the user is going to go into the sessions and they're not going to know that there are um like that's that's not the cool thing. The cool thing is like the RF where you have your repos all laid out for you. +  +  + +### 00:17:52 + +  +**Sally O'Malley:** But may I I don't think I'm asking my question right, but um instead of like a new session up there, could we have like new our a new workspace um plus or a new session? Could we add a tab there for like new work workspace or workflow? +**Daniel Warner:** um yeah the I'll I'll show you let let me show you where the workflows are in the in the structure and if and if you think that it you know it's still sort of like problematic then yeah we +**Sally O'Malley:** Okay. +**Daniel Warner:** can I can suggest some other other ways to to structure it but I think I think I have it pretty close and I and it it you still do get the idea of generic session and and I'll show you that in a second. Uh, Bill Yeah. +**Bill Murdock:** Yeah, I agree with Sally, but we'll see how that turns out. But also, I just find like there's a button for interactive session and a but button for headless section. I don't understand what those are. And like as a new user, why would I understand what those are? +  +  + +### 00:18:45 + +  +**Sally O'Malley:** God, a lot of people don't know what headlift means. Yeah. +**Daniel Warner:** What would your impression be, Bill, as to what these +**Bill Murdock:** Um, my guess is that like interactive session means I can do something and a headless session is just going to happen and I have no involvement with it. But like why would I kick off a session that I don't have any involvement with and can't control and doesn't do anything with me? Uh, Gage, you're on mute. +**Gage Krumbach:** I think headless goes away. It's still a concept that's used within workflows, but if you're going to kick off something, everything I mean, even with our new update, you start a headless session and you restart it, it turns interactive. +**Sally O'Malley:** Sure. +**Gage Krumbach:** I think everything will just be interactive, but have headless capabilities when within a workflow. So, +**Daniel Warner:** Okay. +**Bill Murdock:** Sounds reasonable to me. Dan, sounds good. Thanks. All right. Uh, let's go on. Daniel Goodmore. +**Daniel Warner:** So, so this we enter into the interactive session and this is where things get a little bit juicier. +  +  + +### 00:19:36 + +  +**Sally O'Malley:** Woo\! +**Daniel Warner:** Um, so here, you know, we have the chat interface, which everybody's familiar with that at this point. And you also have um the this is what what I've been referring to it as like the formbbased workflow where you can drive the whole thing from this this sidebar if you want. You don't have to go into the chat. Um, but they both they both stay synced. So, you know, no matter where you start, um, you can continue in the other space. Um so real quick um in the formbbased side of things like in this the order of these things might change um there was a lot of discussion yesterday about exactly when and where and how and what type of repository you need to add but in the existing UI um you really need to add a spec repository before you can do anything. So that's why I have this open by default so that you come here and you're either chatting. So like at this point you could chat um you don't have a lot available to you because you haven't selected a workflow yet. +  +  + +### 00:20:43 + +  +**Daniel Warner:** So you have like this is what I was thinking would be kind of like Sally's idea of a of a just a generic session, right? So you can use that you can use help um the help command uh and I mean you can give it you can give it a prompt as well. Um but you know this would enable you to sort of like chat with you know Claude plus whatever we have for our our system prompt and sort of like walk you through the process of getting set up. Um there are no agents available at this point because there's no there's no spec repository seated. um that's in the chat. So here you go. Add a we'll drive the workflow first in in the formbbased one. So add a spec repo. Um in you know in this demo this user is not has not been set up by their admin to be connected with the GitHub app or um or or or any of the other or or like have been created a project with its own permissions. +  +  + +### 00:21:43 + +  +**Daniel Warner:** So they need to enter their GitHub name and uh their GitHub personal access token. More to the point. Save that personal access token connects to GitHub and you can select your um your spec repository. So here we select our spec repo. +**Sally O'Malley:** I could see I could see a little popup of like what is a spec repo and then a little description of what the spec repo is there. +**Daniel Warner:** Definitely. I think like the education in terms of like that type of development flow is something that we're going to have to like really highlight and seed through this whole thing. +**Bill Murdock:** Yeah, it feels like it might be better handled through the chat instead. Get the chatbot to ask for the repo and you paste it in and then the hopefully the chatbot can be a little smarter than requiring you to put at the end because it can figure out what it's missing or whatever. I don't know. +**Daniel Warner:** Oh yeah, buckle up. Buckle up, Bill. +**Bill Murdock:** Yeah, fair enough. +**Daniel Warner:** I can see it. +  +  + +### 00:22:38 + +  +**Daniel Warner:** So in this case, you save configuration, you have your spec repo, um, but you still need to seed it. And you can see that the like the chat is keeping up with you here. So it's like providing a log of your progress, but also just as as Bill suggested, it's also like capable of walk, you know, holding your hand through the process as well. +**Sally O'Malley:** Oh, cool. +**Daniel Warner:** So no matter where you seed it from, um, the same thing's going to happen. So like see this repository and uh it's just brings up you know the the flat file list showing you like what's in it like the the key the key piece is like um how like to your earlier point +**Bill Murdock:** Yeah, that's nice. +**Daniel Warner:** um Sally like how do they know what a spec repo is and how to how to set it up and all that stuff like this just assumes that one exists which is a little bit of a gap but I think I think we we can work around that. +**Sally O'Malley:** But um if an empty repo will turn into a spec repo if you just provide a an empty GitHub repo when you seed it that's when it becomes the spec repo. +  +  + +### 00:23:38 + +  +**Bill Murdock:** Yeah, it would be nice if you don't already have one if it would make one for you, but that's one more feature. +**Daniel Warner:** Right. +**Sally O'Malley:** That's that's what seating does though. +**Bill Murdock:** Well, now you have to still create the repo. +**Sally O'Malley:** Ah, gotcha. Yeah. +**Andy Braren:** Yeah, that makes sense. +**Daniel Warner:** Cool. So, I'm like I'm I'm kind of leaning hard now on um the the setup of this in like a kind of suggest step by step, but this is also like another potential gap. So, because now the user can go and select agents um if the if the repository is not seated, I didn't show you this, I should have. It just says like you need a seated repository before you can view your agents. And like actually here now you have agents in the chat as well. Um, so, so here you can select your agent or agents that you want to include. +**Sally O'Malley:** Oh, nice. That's so cool. +**Daniel Warner:** Um, I brought this up yesterday. Gage said it already works this way, which is basically like if you don't select any agents, then Claude will just pick agents for you based on like what you're asking for and and what the context is. +  +  + +### 00:24:42 + +  +**Daniel Warner:** So, um, I I'll just remove that for now or or I'll I'll put this as a a message more than a choice. So, okay. +**Sally O'Malley:** Well, yeah, because that that means you're not selecting any. So, not it still feels like you're selecting something. So, I kind of like it. +**Daniel Warner:** Okay. Okay. +**Gage Krumbach:** If you don't select anything, it's still got the possibility of using agents. Unless if you don't select something, then we inject like a don't use any agents kind of prompt. +**Daniel Warner:** All right. +**Sally O'Malley:** Do we? +**Gage Krumbach:** No, I'm Yeah, it's like selecting them says please do use them. +**Sally O'Malley:** Oh. +**Gage Krumbach:** Not selecting them still can use them. It's just it's a black box. Who knows what happens in there? +**Dana Gutride:** Yeah, there this isn't they are I'm noticing with every version that comes out from cloud code they are changing how they address the discoverability and also observability of what agents are doing. So I think this is maybe fine like we just hardcode this and disable it so people say oh I guess it's going to and then they'll ask and be like yeah and we put an info button next to it say yeah it's always automatically selecting them and then it this is pretty useful for people to know that it's happening. +  +  + +### 00:25:53 + +  +**Dana Gutride:** So, however you want to represent this as a way of train like teaching them because they will ask like oh you know like I think it's going to be a point of contention if we don't at least hint +**Sally O'Malley:** Oh yeah. +**Dana Gutride:** that this is happening for them. +**Daniel Warner:** Cool. So, you have Okay, so you have your agent selected. +**Bill Murdock:** So, so what? Go ahead. +**Daniel Warner:** Now, you're getting into workflows finally, right? And again, I should have showed you this when it was in its disabled state, but um if you don't have a spec repo seated, you can still look at the workflows, but they're like disabled. Um but here No, +**Bill Murdock:** So before we move on, this create RF workflow has like first thing it does is create an RF.md and then it creates a spec MD. That seems like just the IIA here seems really weird. Is that already been changed or is is is this the current RF IIA? +**Sally O'Malley:** That's That's Yeah, that's what it is now. +**Bill Murdock:** No, I mean is it already changed in Daniel's design based on the feedback from yesterday? +  +  + +### 00:26:46 + +  +**Dana Gutride:** Yeah. +**Daniel Warner:** no, that's some one thing that we didn't talk about which is yeah in the first step you create an RF.md. So now is your job done like or why do you have to go on to specify? +**Sally O'Malley:** I I think that can be fixed by just renaming RF.mmd to idea MD. +**Daniel Warner:** Yeah. Yeah. +**Bill Murdock:** Yeah. And then and then rename this workflow to to to um specify or something like that or create specification. +**Daniel Warner:** Right. Right. +**Bill Murdock:** Yeah, that sounds like it would address my concern. Exactly. +**Dana Gutride:** Yeah. +**Daniel Warner:** It's it's a good point. So, um uh I the way I have it set up here is like you can run these commands like at any point, but um Gage pointed out yesterday that no, these steps are like dependent on each other. So you like based on your repo, if you don't have an RFMD, then you're not going to be able to run specify. +**Sally O'Malley:** Uh the first two those are the only two that aren't dependent. +  +  + +### 00:27:42 + +  +**Sally O'Malley:** You can run specify without an RFD for reasons but u the other ones are dependent on it. +**Daniel Warner:** Okay. All right. So here we go. Like run this command. And um I realized yesterday that this needs to be like a status here in order to be able to truly drive this workflow completely from the form. Then this like message here needs to become a status message creating RF.md. Um but you can see in the chat the the agents were called the RF was generated um or is being generated and Right. +**Sally O'Malley:** Can you enable streaming or does it do that? +**Dana Gutride:** Yeah, Daniel. +**Sally O'Malley:** Oh, sorry. +**Dana Gutride:** Yeah. No, no, I I just want to share something. So, so the RF this idea is a is an organizational standard we have, right? Spec is separate and and we've conflated those and maybe we shouldn't. So, so we need PMS to bring RFS in a certain format. The specification is needed for engineering after that. +**Sally O'Malley:** Mhm. +  +  + +### 00:28:42 + +  +**Dana Gutride:** mix mixing those two things like and engineering is gonna probably always need some type of specification in the future and maybe we need to separate that because because like even listening to Kristoff yesterday I don't think he got it like the the value of this and he has this idea that what he's already creating for engineering is valuable um and I have I have data to show that it's not so but that's going to be like but I'm wondering that by by mixing spec kit and the RF gener generation if we've if we've if we keep confusing this because that idea phase is critical for PM. +**Sally O'Malley:** Yeah. +**Dana Gutride:** You don't need that as a developer. +**Sally O'Malley:** Yes. +**Dana Gutride:** You if you go to a spec kit yourself and you give it enough information, you're going to get a decent spec out of it. +**Daniel Warner:** Mhm. +**Sally O'Malley:** Mhm. +**Daniel Warner:** Right. +**Gage Krumbach:** Um, can I add something? +**Daniel Warner:** So even more distinction u RF workflow +**Dana Gutride:** Yeah. +**Sally O'Malley:** I I feel like that that that begs for the RF to MD to mirror a Jira card. +  +  + +### 00:29:38 + +  +**Sally O'Malley:** Then a Jira RF the RF to MD should mirror I know we're not talking about Jira. I can see see that from your face. +**Dana Gutride:** I hate Jira, but +**Gage Krumbach:** So I think the ideal use the ideal flow for like Kristoff or a PM would be all they do is iterate on an idea like our very very initial demo which is like hey I made this RF and it's great and then we have a workflow that goes from start to finish all the way to task. No one even touches specify. It's just like first step in the workflow rest of spec kit. No one touches it and then it goes to a repo and then developers who don't want to work on a UI platform just go to the repository grab it and use that to develop or if they want they come to the platform and then start another workflow that's like all right start implementing off this task list or whatever else. +**Sally O'Malley:** Ah, so so you're thinking uh the PM starts the RF. You're you're frozen for some reason. +  +  + +### 00:30:41 + +  +**Sally O'Malley:** Maybe it's me, but the PM um is it Lee? Oh, the PM starts an RF and then clicks a button and is like, "Okay, now just create the PC." +**Dana Gutride:** So I +**Andy Braren:** That's +**Sally O'Malley:** and then tells the engineers about it. And so an engineer's job starts with taking this uh this PM PO and start like iterating on that. I think that's I mean that's exactly what you just said, but I'm going to repeat it because it's kind of cool. +**Gage Krumbach:** Yeah, I mean, yeah, Dana is hitting the nail on the head. +**Sally O'Malley:** Yeah. +**Gage Krumbach:** I don't think we need to teach them spec kit. That's why they're getting confused. +**Sally O'Malley:** No. Yeah. So they do they they they do their idea and then they have a button that says now create the PC. +**Dana Gutride:** No. Yeah, but we need to teach our we do need to teach the engineer spec kit or whatever we land on because the specification is what's going to create enough context for us to actually have a viable code +  +  + +### 00:31:23 + +  +**Bill Murdock:** Makes sense. And +**Dana Gutride:** artifact by the end of the day. +**Gage Krumbach:** Yeah, 100% agree. +**Sally O'Malley:** Maybe just add an option to auto auto um advance through spec kit for a PM, but it it stops along the way. +**Dana Gutride:** Yep. +**Sally O'Malley:** It's you have to be watching it and like it's not just like hit a button and it's done. It won't finish. +**Daniel Warner:** I wonder. +**Gage Krumbach:** Thanks, D. +**Daniel Warner:** Bye. +**Bill Murdock:** So, So +**Sally O'Malley:** Okay. +**Daniel Warner:** Um, I wonder al uh Sally, the person that that you talked to at IBM, did they were they familiar with Speck Kit? +**Sally O'Malley:** They weren't, but um they totally got it. +**Daniel Warner:** Okay. +**Sally O'Malley:** But she's a she's an engineer. Yeah. +**Daniel Warner:** Because the what the way I was thinking from from my perspective, not a developer, keep in mind, but like I was like, this seems like an like a great way to try and use specit whereas like setting it up for myself on my own project seemed like something I didn't really want to do um or that I would have to section off a lot of time in order to try. +  +  + +### 00:32:25 + +  +**Sally O'Malley:** Oh, totally. Yeah. +**Daniel Warner:** So I think there is like a good educational piece in terms of like this is spec kit it's set up you can run it very easily from this this yeah all right so +**Sally O'Malley:** Mhm. I mean it is just pushing a button and reading. +**Bill Murdock:** So, did we just reach a conclusion about RFS then? Because, sorry, I got pulled away like three times. Um, where did we land on whether we're doing RF and how we're doing them? +**Sally O'Malley:** Oops. +**Daniel Warner:** I mean the the the concept consensus seems to be that there there's some confusion around what it means to generate an RF. So, a product manager needs to be able to generate and iterate on an RF and and so like incorporating some of this spec kit stuff is not appropriate in this case, but like the the actual tactical solution to +**Bill Murdock:** Cut it. +**Daniel Warner:** that, I don't know, change some of the words, change some of the display. We got to figure out something that works. +**Bill Murdock:** So tactically you could just remove the word RF alto together like you have ID8 produce idea just like we were saying earlier but then like if you want to then sell this to the PMs as an RFP generator what do you tell them to do uh gauge +  +  + +### 00:33:45 + +  +**Gage Krumbach:** you tell them to just type in the chat. I think we take away all these I think there's two users. The power user can run specific commands. So we have this display um for just like emulating cloud code. But then you have the workflow runner which just says all right we're running through our steps. Hey Kristoff, you need to put something in here. And like okay I'm going to do some things. Hey Kristoff, what do you think about this? It's supposed to be they're asking them questions, follow-ups and getting them out of them. they're taking them down a journey. +**Sally O'Malley:** Yeah. +**Gage Krumbach:** Whereas this um is for power users. It feels more like okay, I got to run this and then there's more to spec kit. There's like clarify. It's like I got to run clarify. It's like there's a lot more to it and you can be much more powerful with it. But you're the goal is to get what you want out of the PM, not necessarily teach them to be a power user. +  +  + +### 00:34:35 + +  +**Bill Murdock:** No, that makes sense. But if we don't take the concept of RF out of here, are we pointing to a particular artifact and saying this is the one you should use as your RF or are we just saying here's here's a million artifacts. Go pick which one you want to use for your RF. +**Gage Krumbach:** I I think we need to stop thinking of specific flows. It's going to be generic. This RF concept, it's just the one we're focusing on now. I was talking to Michael before and it's like we need to have I think we should start thinking of two use cases side by side to sort of keep us in this more generic loop because if we keep on cycling down just everything is just like this RF um flow it's not because another team might have a different feature flow than ours. So we need I I guess saying like we should step back and think I don't know like microcopy things like these can all change to make it more clear on what steps are what but I think like the +  +  + +### 00:35:24 + +  +**Sally O'Malley:** Mhm. +**Gage Krumbach:** core foundational like how a user interacts with the workflow how a user interacts with cloud code is the important bit +**Sally O'Malley:** Mhm. +**Daniel Warner:** and and I'm going to just jump in real quick, Andy, before you go. Sorry. Which is that I like I think when Sally suggested that this RF look more like the thing that goes in for a Jira Strat or whatever. I think that's like that could go a long way. Not that we want to be married to Jira. doesn't have to look exactly like a Jira thing, but it just should look like an RF that you can then copy and paste and take to some other workflow. So, that could alleviate it too. Sorry, Andy. +**Bill Murdock:** Makes sense. But it's not going to be an RFP anymore, right? Sorry, Andy. Go ahead. +**Andy Braren:** It would be right. That's what Narf has, right? It would just be in the Jira formats. +**Bill Murdock:** No, we specifically said it's going to be an idea file and it's going to be you can do whatever you want with it. +  +  + +### 00:36:17 + +  +**Bill Murdock:** Like it's not going to be a thing you have to stick into your RF description. You could stick it into an epic description or a story description or email it as a memo. It's just ideas. +**Gage Krumbach:** Yeah, it's all artifacts at the end of the day. It's just data that the model output that we are using to develop Well, +**Andy Braren:** Yeah. +**Bill Murdock:** Yeah. And we could have an artifact that we call IRF if we want or we don't have to if we don't want to. And I think that was the debate I was trying to get to is are we is there going to be an artifact that we call RF or not? Um and if so, what what would it where in this flow would it arrive? And I think Gage was saying we may not even have flows like this at all. +**Gage Krumbach:** it's it's very dependent on the team. A team might really want RFS. Like they love that idea. RFS are great for them, but then one team's like, "No, we just work on everything is a architectural diagram for us. We +  +  + +### 00:37:06 + +  +**Gage Krumbach:** don't even do design documents." So, it's ultimately up to how the team structures things. They might not use Jira. They might use GitHub. So they'll have different integrations. So like look at I guess like look at this order more of just how a user works through a set of flows rather than always going to be going through a certain flow because I I I think it becomes generic in the end and these things get customizable. Sorry Andy I cut you off. +**Andy Braren:** No, good. You have a thought, Bill, before I jump in. Um, I agree. +**Bill Murdock:** Uh, yes. So, Andy, go ahead. +**Andy Braren:** I think there's certain microcopy that we're seeing in lefth hand side that's confusing us a little bit but I totally think that ultimately um Rory product management should own the create RF workflow and it's shared across all the PMs they're all using it and they can decide you know what the final step here should be create something that's called RFMD that's fine whatever it'll be properly formatted in Jira format whatever they decide the important thing is that create RF is the very first use case and the very first workflow that we're helping PM to sort of make and define um will take care of the back end specit infrastructure what what steps are required but +  +  + +### 00:38:15 + +  +**Andy Braren:** ultimately like yeah I think PM owns that workflow they can determine these uh they maybe together with with us on engineering can figure out what are the steps to get there and this interface just helps them walk through those steps by steps it's almost like a like a checklist kind of a things they have to do but the final output of which can be and probably should be for you to make it more understandable RF to MD that they can very easily just copy paste into whatever work other tools they want I guess um +**Bill Murdock:** You're suggesting that this is something that like the user would create. The workflow is something user would create. So the like ambient code platform wouldn't have an RF creation workflow. It would have a general purpose workflow editor and some some users might create a RF workflow if they wanted to. +**Andy Braren:** Yeah, I think that's where we're going next. +**Bill Murdock:** That seems like +**Andy Braren:** Yeah, it and that's I think that's part of the thing that confuses us all about this effort like kind of initially pitches is oh it's an RF builder and that's all it'll be. +  +  + +### 00:39:05 + +  +**Andy Braren:** No, I think our mindset's shifting toward we're making a generic platform to run uh help users and help internal teams run whatever workflows they desire. Um, augmented by by AI, augmented AI, like that's a project name, right? So, I think that's sort of where we're going and this workflow. This create RF1 is the very first stab at that. +**Bill Murdock:** Yeah, it makes sense. And that microcopy on this one needs work, but once it gets settled out, then it will be a decent illustrative example, I guess. +**Andy Braren:** Totally agree with that. Yeah. Yes. +**Sally O'Malley:** Uh yeah, I think a really important thing to do is just um define or understand what the difference is between uh RF.mmd and spec. MD, not not the naming, but like what's what's the difference in those two steps? Cuz that's a bit confusing. Um, even I I mean, I know what the difference is, but it I could see where that could be really confusing because it's like uh you take the RF and then you just what further um refine it into a another a more refined RF is what a spec is. +  +  + +### 00:40:11 + +  +**Sally O'Malley:** But and and these are the fir these are the two phases though that we are focused on for this first pilot. Am I right? I'm right about that. +**Daniel Warner:** Yes. And I think that's why, you know, I mean that that's what we sort of like agreed on right at the outset, which is why I sort of like cut it off there. But, you know, I think this conversation just highlights like, all right, what's what's the what's the desired end state here for a product manager? Like, what's the thing that that we want them to do? Like, do they do is this good enough that they have their their these sort of artifacts or do we need to be have something more explicit? +**Bill Murdock:** Well, they definitely need to iterate, but this UI lets them do that too, right? +**Daniel Warner:** It it does if you're driving the whole thing through the form like it's a little harder to iterate on the actual file. Um you probably would have to do that like on the file level which which you can do. +  +  + +### 00:41:09 + +  +**Daniel Warner:** So once the the files are created I just I realized in watching the video yesterday that you guys aren't seeing what I'm seeing. So when I click on these files they're opening in a in a window. +**Bill Murdock:** another window. Okay, gotcha. Oh, and then you manual edit. I don't want to manually edit. I want to go into the session and say, "No, drop the stuff about um wagg 2.1. I +**Daniel Warner:** Right, right, right. +**Bill Murdock:** don't think that's appropriate for this. Um, yeah. +**Daniel Warner:** So that that would be Yeah, that would be the chatbased workflow, right? Which is like yeah like okay I want to yeah remove these dependencies or whatever and you can iterate in that way. +**Andy Braren:** we talked sorry I think we we talked about this a little bit yesterday too that you know the ability to view the actual artifact inside this interface may or may not be helpful. +**Daniel Warner:** Um +**Andy Braren:** I know it's a it's a potential rabbit hole, but I I also sort of lean toward even looking at like um I don't know what cursor and other tools or or in cloud's web interface or open AI's interface is starting to get to. +  +  + +### 00:42:08 + +  +**Andy Braren:** Uh there's a convention or a pattern starting to emerge where there is sort of like an artifact browser or viewer or something that like appears in the right hand side. Maybe this evolves into that where there's, you know, um after you generate artifacts, you can click on one of them, one of the things that's been generated and then see that preview or see potentially even the live PR or code or whatever files like on the right hand side potentially. Um I imagine it's getting to that point eventually, but for now, for initially, I think just being able to click on one of those artifacts and have it open somewhere is okay, but I think artifact viewers probably are in our future eventually is my guess, my hunch. +**Bill Murdock:** Yeah, artifact yours is nice, but I think it's much more urgent to have iteration interactive iteration on the artifact. +**Andy Braren:** that'll be supported regardless I think it's an interface but seeing the artifact together alongside you iterating on it actively I think that'd be the next thing that we support +**Bill Murdock:** Well, yeah, that's fair. +  +  + +### 00:42:57 + +  +**Bill Murdock:** But and Daniel, you were saying that that this is not something supported in the short term, right? That iterating on the artifact is not something in your design. +**Daniel Warner:** Not not not on in like a I'm editing the text type of situation. I was thinking that these like the results of the workflow would right now I just have them opening in another window, but I would say like they would open in either like the GitHub editor, right? go go to where the file lives and you can edit it there. Um because especially since you can also like add other agents to help you out or whatever. +**Bill Murdock:** Yeah, and that's that's also useful, but it's not the same as being able to tell the bot I want something different and having it in update. Yeah, exactly. +**Daniel Warner:** Um there +**Bill Murdock:** Casey, can you review this and suggest any edits? Yeah, exactly. +**Sally O'Malley:** But that that's already possible though that it does that. +**Andy Braren:** That should +**Sally O'Malley:** There's Yeah. +**Bill Murdock:** But but in Daniel's design, it doesn't, right? +  +  + +### 00:43:43 + +  +**Sally O'Malley:** No, it does. Uh it's just the the through the session through chat you can say, "Oh, it'll it'll tell you, oh, I've created RFA. MD." And then you go to the chat and be like, "Well, I want to change it." And it'll be like, "Okay, what do you want?" It does that. +**Bill Murdock:** and then it will save it as RFMD. +**Sally O'Malley:** Yeah. Yeah. I mean, we you you could tell it to rename it, too. +**Bill Murdock:** Yeah, that makes sense. And that solves the problem. I I guess I thought Daniel was telling me that it won't his design won't do that, but uh +**Daniel Warner:** No, no. Like, so like yeah, the idea is to be able to drive like a more interactive workflow through the chat. +**Sally O'Malley:** Yeah, as long as the session's alive and running, it will +**Daniel Warner:** So you go through all the same steps. Um, you know, you guys you guys get it, but and then you could continue to iterate on the artifact um in the chat. +  +  + +### 00:44:31 + +  +**Bill Murdock:** Yeah. Okay, that's what I was asking for. Thanks, +**Daniel Warner:** So now it's seated. So now you can create your RF. +**Sally O'Malley:** And so did you do all of this by changing the front end and like the back end and the are pretty much Oh, cool. +**Daniel Warner:** So that's how I started, but it was just going way too slow. So this is just static HTML and JavaScript. Um um correct. +**Bill Murdock:** See, the responses are hardcoded, right? You're not actually calling Claude. Yeah, it makes sense. +**Daniel Warner:** They're they're generated, but they're not I'm not calling Claude in any real way. Um so, but like that's what maybe since because honestly I wanted to get it out fast. I wanted to do a couple iterations before we meet next week and just see if like take your temperature, see like is this look like a good direction or not. But now that it seems like, you know, yeah, there's some there's some still some big issues with it, but there, you know, there's enough here that people are responding positively to that we can start to actually make real pieces. +  +  + +### 00:45:36 + +  +**Daniel Warner:** And in my the next prototype, I'll I'll work with what we got already. +**Bill Murdock:** Yeah, I think it's a good incremental update. I guess I would prefer a more of a blank slate kind of start over, but um I see the downsides of blank slate start over. Like in particular, I really want something that just runs on my computer, but uh I know that's not everybody's wish. +**Daniel Warner:** Yeah, I get that. I mean, to to your first point, when I came into this team, they were already hauling ass. So, I figured I'm not gonna, you know, I didn't want to be the one to be like, let's let's take a step back. +**Andy Braren:** What +**Daniel Warner:** Um, and I think that there was enough, you know, the direction was was was already there. Things were already happening. So, it just didn't feel like the right time. And I think that and I and also I did see a path from where they were to where it needed to be in order to like start onboarding users. +  +  + +### 00:46:28 + +  +**Daniel Warner:** So, um, that was that for this for the second piece. What was your second point, Bill? +**Bill Murdock:** Um, I think my my point was just like I would want to do a blank slate redesign that runs on the computer and not on a server. +**Daniel Warner:** Oh, and then running locally. +**Bill Murdock:** Yeah. +**Daniel Warner:** That's something that I that I did not really think through and not completely sure how that would work. gauge. +**Gage Krumbach:** I think yeah I mean going blank slate to do that it's already built with local in mind things are it depends on the workflow you're working with and like how you want to do this eventually we will have an MCP server or a CLI or whatever you can go locally and kick off jobs from your local cloud code or your local cursor Um it it's at the end of the day this thing is a hosted like +**Daniel Warner:** He +**Gage Krumbach:** like agent service or workflow service where you can run through workflows you run through agents um and because PMs don't have cursor they don't want to touch cursor that yeah I mean if everybody just was a developer +  +  + +### 00:47:28 + +  +**Bill Murdock:** Yeah, but if you could just push all those agents in the cursor, then why do you need a hosted something or other? I don't know. I know. I maybe I think if this did this all well, I think PMs would be willing to download your server and start using it. +**Gage Krumbach:** then yes we would probably just be working all within a GitHub repo when things would be easier, but that's just not the case. That +**Bill Murdock:** But it's possible I'm wrong. Uh Andy +**Andy Braren:** uh to to our conversation in Slack about privacy in that element. I think there's eventually um eventually need to have like a local environment even for PMs or something usable by other roles that might even include like personal context or things they wouldn't want to have in a posted platform. So I agree with you Bill. I feel like the local use case there is something there eventually. Um and this might be sort of a tangent but I I maybe Gage or Sally can answer this. Um, is that really a hard requirement to have a full-blown CRC uh like a Open Shift local running locally? +  +  + +### 00:48:31 + +  +**Andy Braren:** I mean, it can just be a few containers and whatever, right? Right now it's just the overhead's super high. +**Sally O'Malley:** That's what I Yeah. +**Andy Braren:** Yeah. +**Sally O'Malley:** Yeah. We were thinking, Michael and I were talking about this yesterday. I wonder if we could um just run a pod. Uh the operator is very Kubernetes specific, but um other than that, I think we could just run things in containers and pod in a pod. +**Gage Krumbach:** There's we we've been actively trying to get it to run Kubernetes native too. +**Sally O'Malley:** Yeah. +**Andy Braren:** Cuz +**Gage Krumbach:** So kind clusters should work where like you just do kind and then a script and then it should be good and then you don't have to have that. It's a lot lighter than CRC. CRC is pretty heavy. +**Sally O'Malley:** Yeah, the difference is yeah, CRC is Open Shift specific and so if we had things in there that like only run on Open Shift like we did um until a few days ago, then Kind wouldn't work. But now I think Kind would work and it's much easier. +  +  + +### 00:49:15 + +  +**Gage Krumbach:** Yeah. +**Bill Murdock:** Yeah, it kind of sounds good for like developers developing the thing, but uh in terms of a user experience be nice just just like be in cursor or something along those lines. +**Sally O'Malley:** Yeah. +**Bill Murdock:** U you said something about the swarm use case. Do you mean like multiple people trying to collaborate? +**Gage Krumbach:** Um, sorry. +**Daniel Warner:** multiple agents. +**Gage Krumbach:** Um, the swarm case is is probably one of the main sort of end goals for this. It's like, yes, we get the processes for closed down. Now imagine a world where you have bots scraping Jira, pulling Jiraas um and then sending them out to workflows and agents then coming back and then iterating. And then you have the same thing for UX research jobs. did the same thing for RFS being refined and then it's kind of what like people like power users that use agent today agents today at cursor or cloud code to kind of just like bounce around between projects and like answer question answer question like I'll have four projects over yeah and that's what we want like PMs to be doing is jumping it's context switching but like you're putting in it's like hey answer this question okay great +  +  + +### 00:50:13 + +  +**Sally O'Malley:** That's what I do. Yeah. I've got like five different projects going at the same time. Yeah. +**Gage Krumbach:** let me go do some work for you hey answer this do some work for you. You're adding like your value is that human in the loop and that's what we're doing all these steps. Now we're just trying to bring that from developers to everybody. +**Andy Braren:** Yeah. +**Bill Murdock:** Yeah, but I don't see the relationship between that and having to run on a server. +**Andy Braren:** Sorry. Go ahead, Bill. +**Bill Murdock:** But maybe I'm missing it. +**Gage Krumbach:** It's it the swarming aspect is like otherwise you're going to have to be running all these yourself on your own machine. like somewhere is gonna have to run that like it's I don't know. I mean I guess we could make it. +**Bill Murdock:** for a minute, but like the computer is very light on this because all the work is being done by Clyde. +**Gage Krumbach:** Yeah. But then there's also the collaboration aspect. It's like okay I started this and now okay well someone's going to pick it up from me. +  +  + +### 00:51:14 + +  +**Gage Krumbach:** Maybe we have four PMs in the room and they're all working on the same RF for a reason and they're answering questions or maybe it's like PM UX and engineer and they're all answering different questions for the same session or whatever. +**Bill Murdock:** Yeah, that makes sense. And if it was all just the same artifact, that's fine because that's in GitHub. But if it was the same session, then then you you'd either need to put the session into GitHub, too, or you would need to um some other way of sharing sessions. +**Gage Krumbach:** Yeah. I mean it's more of like a generic concept. +**Bill Murdock:** Yeah, that's +**Gage Krumbach:** It's not like not technically I don't know if it's always going to be get up or it's going to be some other means but like that concept of collaborating on some agentic flow is kind of what I'm talking about. +**Bill Murdock:** Yeah, that makes sense too. Andy. +**Andy Braren:** uh two things. So the first uh when we get into like collaborate uh collaboration artifacts together between different people or groups and things I think it's sort of a next step uh because yeah you could go into GitHub but there might be a need to have even collaboration with on a textbased artifact or the RF inside this tool and we'll get that as a natural you know next request from the PMS we're building this tool for. +  +  + +### 00:52:21 + +  +**Andy Braren:** Otherwise, their current workflow very likely for Kristoff and others will be great, just copy this, paste into Jer or paste into a Google doc where they can collaborate with other PMs and refining text and whatever. And once they do that, the fact that that's now in an external system and where you'll have control of the data or the actual original artifact, it's kind of a problem for the future steps of this this process. Um, so that's a I think it's a problem a next problem for us to solve after we nail this. Um, the second thing around the the swarms and whatnot, I agree with Bill. I feel like you could have swarm running locally or just a bunch of pods or something that spin up or containers that ultimately call different external APIs for actual work to be done. Um, yeah, tabs are something around here and we can make it easier and to to your point like there is another emerging pattern around like aentic inboxes or something or like a not that we all love inboxes but +**Bill Murdock:** or tabs. +  +  + +### 00:52:59 + +  +**Bill Murdock:** You could have tabs in a interface or thing. Yeah. +**Andy Braren:** another like list of all right you have these five different projects across different things are happening and you're needed as a human for a review on these five things. click each one very easily dive into an area, look at the artifact, provide feedback, pull back out of your inbox, go back into another one, and you make that context switching easier than even what this interface shows. So, that's another augmentation in a phase two. I kind of see um the last thing I want to say, sorry Sally, to your point about workspaces in the chat, another conversation we had yesterday that you weren't here for, but um what we described earlier about those workflows being managed by the PM team of Open Shift AI somewhere somehow um that might necessitate the need for another level in this organizational hierarchy of a workspace or a team or whatever the heck we call that thing, but there needs to be some arbback grouping of like, all right, the PM's going to edit there uh you workflow workflow RF feed-workflow MD or whatever the file format that is to to define and work in that collectively. +  +  + +### 00:54:04 + +  +**Andy Braren:** Um so those things be being on the maybe in our phase two or or feature enhancements. +**Sally O'Malley:** Yeah. +**Andy Braren:** But um yeah Daniel +**Daniel Warner:** Um, yeah, actually I think a lot of it what I was going to say has been covered, but I guess just to put a kind of a fine point on like the multi- aent aspect of this is that you know while you you know as a developer you're working with with Claude and you're working or you're working in cursor And the cursor agent is great and it's great at managing sub agents and it's really effective and all that stuff, but you know there there there is a a point in time in the not too distant future where the a multi- aent setup is not going to be um able to be contained like just within cloud code or or um or or cursor and and I and especially not for people who aren't developers. Right. So developers will live locally I think for a lot longer than most people. But for but for for a lot of people it's like okay if I want to use like a multi- aent setup what do I have to do and rather than building out like a local sort of like desktop experience it does make sense I think in my opinion to have something that's hosted that's living on a cluster that has all the resources it needs to to spin up agents ad hoc based on on the tasks that +  +  + +### 00:55:34 + +  +**Daniel Warner:** you're giving it. Um but but any that that was just that was my sort of like highlevel thought like um it's going to be tough to compete with with cursor and claude at this point. Um but as things evolve I think it's going to make a lot more sense. Um, and also the and I think this was covered as well, but like the just the integrations with business systems, you know, like I I know that that is possible through like, you know, cursor MCP stuff. And I'm not sure how cloud code uses MCP because I haven't done it yet, but like um you know, having all of the the context available like Andy's always talking about of like changes that are happening in Jira or changes that are happening in other like pro project and product management stuff. Being able to just access that at con as context also really sort of like contributes to the idea of this as like a hosted solution that that lives in a cluster. And anyway, that's that's more my opinion than anything else. +  +  + +### 00:56:32 + +  +**Daniel Warner:** But it's I I mean I just recently switched to cloud code from cursor and that experience is unreal. +**Bill Murdock:** Yeah, those are good points. I They don't make me happy because I want the local thing, but I I understand and I I see why the other people don't like what I like. Yeah, fair. +**Daniel Warner:** It's it's it's so good. So like it's going to be tough to compete with that for developers in the short term. Um anyway, okay, we're just about at 3:30, so unless anybody has any parting thoughts, I think we could probably wrap it there. +**Bill Murdock:** Thanks everybody. +**Daniel Warner:** Thanks. +**Sally O'Malley:** One one one thing is like how far away are we from having something that looks more like this than where we are? Is this next week we'll have it do you think? Or you know that's what I'm wondering. +**Andy Braren:** I was going to propose it actually the same idea like can we just try to make this work next week? That'd be awesome if so. +**Sally O'Malley:** Yeah. +  +  + +### 00:57:28 + +  +**Sally O'Malley:** Like Monday we're all here. +**Andy Braren:** Yeah. +**Sally O'Malley:** Are you all traveling Monday? +**Gage Krumbach:** I'm traveling half Monday, but I'll work on the plane. +**Sally O'Malley:** Yeah. +**Daniel Warner:** So, I like I talked to to Bob a little bit about that real quick after our call yesterday and I think just based on from what he said on the call and what he said after like there's gonna we're going to be split up into like different projects and probably the project that like Andy, me, him, maybe one or two other people are working on is going to be this. Um, so I I don't know. I don't want to put words in his mouth, but that was the impression that I got. +**Sally O'Malley:** Do you anticipate it being all front end changes? +**Gage Krumbach:** So, so y'all see this? +**Sally O'Malley:** Gage, you know more about like the interaction. Yeah. +**Gage Krumbach:** I think um this is what was merged. I wasn't part of the merging, so I'm kind of just seeing this. You have a number on your name and that name goes here. +  +  + +### 00:58:22 + +  +**Gage Krumbach:** Um first work stream getting started. So, I think this is I believe this is more of like the UX flow kind of workstream. And then there's two other like um bring your own plugin which is Michael is on that one and some others. Daniel, you're on that one too. Um so I don't know. I I also assume we're going to be in the same room so I don't know how like cohesive these work streams are. Um, I I'm on this one. So, I plan on doing a lot of uh I probably will I want to do like generic workflow stuff. I don't know what this says, but I think I I want to get that to work because I think that opens up a lot of use cases, makes things visible. Um, but this is yeah, this is the doc. I'll share it if people want to look at it more. +**Sally O'Malley:** Yeah. Oh, but yeah, one more qu the the question that I had. Do you anticipate like to get to what Daniel's showing, is that mostly frontend changes because Mhm. +  +  + +### 00:59:31 + +  +**Gage Krumbach:** Um, well, I think there's a fundamental difference where you might have noticed there's no workflow page anymore. It's there's no like session workflow page. It's all session pages. So, I think we need to like technically think through how that works. Daniel, I know you said you were um didn't didn't uh there was like a disconnect. +**Sally O'Malley:** Yeah. +**Gage Krumbach:** I don't think like the remote was as clear as it could have been in the old design. So, like the workflow page now is just a representation of the remote GitHub whereas the session page is a representation of the workspace. like here it's kind of merged and we need to sort of at least technically bridge that gap again. Um may like hopefully we don't have to do it visually so things just feel seamless but technically I think that's the biggest thing. Otherwise it is just a lot of uh quick fixes as well as some more fundamental changes. But yeah and that's at least from my impression of looking at the mocks and trying to translate it. +  +  + +### 01:00:36 + +  +**Gage Krumbach:** That's what it sounds like. +**Daniel Warner:** Cool. Um, oh, I do have one quick question. Sorry to keep expanding this, which is like, so like I I do have a branch with this prototype on it. Should I just make a fork and then share that or do you guys want to give me push access to this thing? +**Sally O'Malley:** Uh, you have a branch of V team. +**Daniel Warner:** Yep. Yeah. +**Sally O'Malley:** That's fine, right? +**Gage Krumbach:** I'm like for this for this demo is what you're saying and you're I'm confused. +**Daniel Warner:** Yeah. +**Gage Krumbach:** You say you want to like merge this demo into P team. +**Daniel Warner:** No, no, I don't need to merge it, but just to make it available to you. Like I could I could just make my own fork and then you send you a link to that or do you want me to just, you know, push a branch to the project and there? +**Sally O'Malley:** Yeah, do the main one. +**Gage Krumbach:** Yeah. +**Daniel Warner:** Yeah. +**Sally O'Malley:** I either way works. Um I don't I don't know. +  +  + +### 01:01:34 + +  +**Gage Krumbach:** Yeah. +**Sally O'Malley:** Um uh yeah, I've I usually I always push a a fork. I always create a fork and and push a branch to a fork, but and and I I'm curious to know like how far Cloud would go if you gave it the HTML and was like like use this +**Daniel Warner:** Okay. +**Gage Krumbach:** Is this just running like mock data, Daniel? +**Daniel Warner:** All four. Yeah. Yep. It's all It's all just a static prototype. +**Gage Krumbach:** Okay. +**Daniel Warner:** Yep. +**Gage Krumbach:** Yeah. And I think like our fork branch is probably fine. Yeah. +**Sally O'Malley:** HTML and make make this work, you know, in this codebase. +**Daniel Warner:** Yeah, it's worth trying to shove that through a couple times and see if we could just make it happen. +**Sally O'Malley:** I wonder how Yeah. +**Daniel Warner:** Yeah. +**Gage Krumbach:** I should be pretty successful. +**Andy Braren:** Maybe we should try that next week. Yeah, if the APIs are available, we can just compare the code bases and whatever and have it just figure it out. That'd be sweet. +  +  + +### 01:02:19 + +  +**Sally O'Malley:** Yeah. Do you think that Opus would be is is the best model to use for coding? Is it I I Yeah. +**Gage Krumbach:** I think I think any max model would do fine. Just the screenshots in and tell it to make a plan and go there. Go from there. Um find the diffs. It's It's I think it's more of like better prompting that would get you there than just bigger models. +**Sally O'Malley:** Yeah, because this is a complic this is a complicated thing to orchestrate. It's it's the the codebase is complicated. There's there's Python, there's TypeScript, there's Go. And so I really I want to make this happen as fast as possible. And um maybe +**Daniel Warner:** I I actually now that I'm thinking about it like I actually would have high hopes for that approach. I don't think we could just shove it all through at once, but if we broke it up, you know, and say like, you know, update whatever the pro project page to be like this because it's all that like um that uh I can't remember the name of the front-end framework that you used shad CN or something like that, you know, seems very straightforward and claude knows its way around it pretty possible. +  +  + +### 01:03:17 + +  +**Gage Krumbach:** Yeah. Yeah. +**Sally O'Malley:** Yeah. Yeah. +**Daniel Warner:** Yeah. +**Gage Krumbach:** Yeah. just I I'd like to whiteboard some of the complex inner workings a bit because there's two things in there like how fast the pod spins up which is just not possible with how we do it. It kind of like leans itself leans itself towards a a constantly running cloud code session which seems cool and but it changes fundamentally things and also just like how that getit integration works because that's not fundamentally there that we would need to sort of work through just so it doesn't go off and just lose features. +**Sally O'Malley:** Yeah. +**Gage Krumbach:** But otherwise, I think it's a great idea. +**Daniel Warner:** Okay. +**Gage Krumbach:** This has been great. +**Daniel Warner:** Yeah. Thanks for the the the great session and um I'll see you all you all next week. +**Gage Krumbach:** Thanks for the demos. Those are awesome. +**Daniel Warner:** Yeah, my pleasure. All right. Bye. +**Andy Braren:** think it is. +**Gage Krumbach:** Sally, do you want to stay on it? Okay, we'll see. If not, we'll just pick up a new one. +**Andy Braren:** It is recording. Stop that. But yeah. Yeah. Whatever. All right. +  +  + +### Transcription ended after 01:04:53 + +*This editable transcript was computer generated and might contain errors. People can also change the text after it was created.* \ No newline at end of file diff --git a/static-prototype/design_path/prototype_version_1_feedback/curated_feedback.md b/static-prototype/design_path/prototype_version_1_feedback/curated_feedback.md new file mode 100644 index 000000000..8c52f631e --- /dev/null +++ b/static-prototype/design_path/prototype_version_1_feedback/curated_feedback.md @@ -0,0 +1,499 @@ +# vTeam Platform Feedback + +Early feedback from the Ambient Code Platform team. + +--- + +## IMPORTANT: Scope Constraint for AI Agents + +**CRITICAL INSTRUCTION FOR CLAUDE CODE AND CURSOR:** + +**ALL changes related to this feedback MUST be constrained to the static prototype ONLY.** + +- **Working Directory**: `static-prototype/` +- **DO NOT modify**: `components/frontend/`, `components/backend/`, `components/operator/`, or any production code +- **Scope**: This feedback is for design exploration and prototyping only +- **Purpose**: Iterate on UX/UI concepts before implementing in production + +When implementing feedback items: +1. All file paths mentioned refer to their equivalent locations in `static-prototype/` +2. Make changes to HTML/CSS/JS prototype files only +3. Do NOT create or modify TypeScript, Go, or Kubernetes resources +4. Focus on visual design, layout, and user flow changes +5. Document prototype changes in `static-prototype/CHANGELOG.md` or similar + +**Example Path Mapping**: +- Feedback mentions: `components/frontend/src/app/projects/[name]/layout.tsx` +- Actually modify: `static-prototype/[equivalent-html-file].html` + +If you need to make production changes based on this feedback, create a separate issue or task list and consult with the team first. + +--- + +## Resources + +**Video Walkthrough**: https://drive.google.com/file/d/18O98fAN1alz2XuZWBr9L9MrlXB5NxwIO/view?usp=sharing + +**Meeting Notes (Gemini)**: [Chat UI Feedback - 2025_10_30 15_56 EDT - Notes by Gemini.md](./Chat%20UI%20Feedback%20-%202025_10_30%2015_56%20EDT%20-%20Notes%20by%20Gemini.md) + +**Version 1 Prototype Feedback**: [my_notes.txt](./my_notes.txt) + +**Session 2 Notes (Gemini)**: [Chat UI feedback session 2 - 2025_10_31 14_29 EDT - Notes by Gemini.md](./Chat%20UI%20feedback%20session%202%20-%202025_10_31%2014_29%20EDT%20-%20Notes%20by%20Gemini.md) + +**Session 2 Transcript**: [Chat UI feedback session 2 - 2025_10_31 14_29 EDT - transcript.md](./Chat%20UI%20feedback%20session%202%20-%202025_10_31%2014_29%20EDT%20-%20transcript.md) + +--- + +## Feedback Status Guide + +- **Actionable**: Should be addressed +- **Ignore**: Explicitly marked to skip +- **Needs Clarification**: Requires more information + +--- + +## Security & Permissions + +### [Actionable] GitHub Integration Access Control (Gage) +**Issue**: Moving GitHub integration out of user's own access opens us up to situations where a user may now get to see repos they don't have actual access to. + +**Component**: `components/backend/handlers/github.go`, `components/frontend/src/app/integrations/` + +**Action Required**: +- Review OAuth scope implementation +- Ensure repository access respects user's GitHub permissions +- Add RBAC checks for repository visibility + +--- + +## UX & Terminology + +### [Actionable] Session vs Workflow Confusion (Gage) +**Issue**: Confused a bit on the role of a session and workflow - it looks like sessions ARE workflows. + +**Component**: Documentation, Frontend UI labels + +**Action Required**: +- Clarify terminology in documentation +- Update UI labels for consistency +- Consider renaming or better differentiation + +### [Ignore] Workflow as Collection of Sessions (Gage) +**Status**: IGNORE - Design decision already made + +**Note**: Today workflows are a collection of sessions in part so other people can collaborate on a single workflow. + +### [Actionable] API Keys Navigation (Jeremy Eder / Version 1 Feedback) +**Issue**: We have API keys on the left sidebar and then fields for other API keys in the settings tab. I know they have different uses, but isn't it confusing? + +**Additional Context**: Hide API keys from the project view for now until we have Jira integration. + +**Component**: `components/frontend/src/app/projects/[name]/layout.tsx` (sidebar), Settings page + +**Action Required**: +- Hide API keys from project view navigation until Jira integration is implemented +- When re-introduced, rename one section to be more specific (e.g., "API Keys" → "Service Keys" or "Integration Keys") +- Add clarifying descriptions to both sections +- Consider consolidating if they serve similar purposes + +### [Actionable] Project Information Tab (Jeremy Eder / Version 1 Feedback) +**Issue**: Project information - either drop it or put something useful there. Maybe we create a metrics tab or something instead. + +**Additional Context**: Move Project info to overview page. + +**Component**: `components/frontend/src/app/projects/[name]/page.tsx` + +**Action Required**: +- Move existing project information content to the overview page +- Evaluate current project info page content +- Option 1: Add useful metrics (session count, cost analytics, activity timeline) +- Option 2: Remove tab entirely if no valuable content (preferred after moving to overview) +- Recommended: Consolidate into overview page with metrics/analytics dashboard + +### [Ignore] Chat Interface Complexity (Jeremy Eder) +**Status**: IGNORE - Too subjective, needs user testing first + +**Note**: Chat interface - I'm torn. I think we are surfacing too much detail overall. There are too many choices. + +### [Actionable] "Associated Repository" Terminology (Jeremy Eder) +**Issue**: What does "associated repository" mean? I need a clearer word used there. + +**Component**: Frontend session creation forms, documentation + +**Action Required**: +- Replace "Associated Repository" with clearer term +- Suggestions: "Source Repository", "Code Repository", "Git Repository", "Working Repository" +- Update all instances in UI and docs + +### [Actionable] Remove "Headless Session" Terminology (Session 2 - Bill Murdock, Sally O'Malley, Gage Krumbach) +**Issue**: The term "headless session" is confusing for new users. They don't understand what it means or why they would choose it. + +**Timestamp**: 00:17:52 - 00:18:45 + +**Component**: Session creation UI + +**Action Required**: +- Remove "Headless Session" as a separate session type +- All sessions should be interactive by default +- Headless capabilities should be contained within workflows, not exposed as a session creation choice +- Note: When a headless session is restarted, it already becomes interactive, so this simplifies the UX + +### [Actionable] Rename "RF.md" to "Idea.md" (Session 2 - Sally O'Malley, Bill Murdock) +**Issue**: The "RF" (Request for Feature) terminology is confusing and too prescriptive. Users don't understand what RF means. + +**Timestamp**: 00:26:46 + +**Component**: Workflow artifacts, UI labels + +**Action Required**: +- Rename `RF.md` to `Idea.md` throughout the UI +- Update workflow step descriptions to use "Idea" instead of "RF" +- Consider renaming the workflow from "Create RF" to "Create Specification" or similar +- Make the artifact format more generic so it can be used in various contexts (Jira, email, epic description, etc.) + +### [Actionable] Add Spec Repo Education Tooltip (Session 2 - Sally O'Malley) +**Issue**: Users don't understand what a "spec repo" is or why they need one. + +**Timestamp**: 00:22:38 + +**Component**: Session creation UI, spec repo configuration + +**Action Required**: +- Add tooltip or popup with "What is a spec repo?" explanation +- Educate users on the spec repo concept before requiring them to set one up +- Consider inline help text in the form + +### [Actionable] Move Integrations to User Menu (Session 2 - Gage Krumbach) +**Issue**: Integrations should be in the user dropdown menu to reinforce that it's user-scoped, not project-scoped. + +**Timestamp**: 00:10:24 + +**Component**: Navigation structure + +**Action Required**: +- Move "Integrations" from main navigation to user dropdown menu +- This reinforces that integrations are per-user settings, not per-project + +### [Actionable] Improve Agent Selection UI (Session 2 - Dana Gutride, Gage Krumbach) +**Issue**: The agent selection UI looks like users must make a choice, but Claude auto-selects agents anyway. + +**Timestamp**: 00:24:42 + +**Component**: Agent selection interface + +**Action Required**: +- Hardcode "Auto-select agents" as the default behavior +- Add an info button explaining that Claude automatically picks agents based on context +- Don't make it look like a required choice +- Consider disabling the selection and just showing "Agents will be automatically selected based on your request" + +### [Actionable] Live Markdown Rendering (Jeremy Eder) +**Issue**: Is it possible to render the markdown in the status pane live, as it's being generated? + +**Component**: `components/frontend/src/app/projects/[name]/sessions/[sessionName]/page.tsx` + +**Action Required**: +- Implement streaming markdown renderer +- Use WebSocket updates from backend +- Progressive rendering as content arrives +- Consider using React Markdown with streaming support + +**References**: +- WebSocket implementation: `components/backend/websocket/websocket_messaging.go` +- Session status updates + +### [Needs Clarification] Task Popup Suggestions (Jeremy Eder) +**Issue**: I like how the chat had popups. I wonder if we can keep raising popups of the next most likely task. These popups give us the opportunity to gain advantages from prompt templating like what SpecKit is doing in the background. + +**Component**: New feature - AI-powered task suggestions + +**Action Required**: +- Research SpecKit prompt templating approach +- Design popup/modal component for task suggestions +- Integrate with Claude API for next-task predictions +- Create prompt templates for common workflows + +**Status**: Needs product/design review before implementation + +--- + +## Navigation & Layout + +### [Actionable] Remove Workflows from Project Page (Session 1) +**Issue**: Remove Workflows from the project page. + +**Component**: `components/frontend/src/app/projects/[name]/layout.tsx` + +**Action Required**: +- Remove "Workflows" from sidebar navigation items +- Verify no broken links remain +- Update any documentation referencing this section + +**Implementation**: +```tsx +// File: components/frontend/src/app/projects/[name]/layout.tsx +// Remove this item from the items array: +// { href: `${base}/workflows`, label: "Workflows", icon: WorkflowIcon } +``` + +--- + +## Workflow Behavior & UX + +### [Actionable] Workflow Step Dependencies (Version 1 Feedback) +**Issue**: Each step in a workflow depends on the successful completion of the step before it. For example, if the /spec command needs /ideate to have successfully run. A successful run of a step is determined by whether or not it generated an artifact. For example, if there is no rfe.md generated then /spec is disabled. + +**Component**: Workflow step logic, RFE workflow implementation + +**Action Required**: +- Implement sequential step dependency validation +- Add artifact existence checks before enabling subsequent steps +- Disable steps that depend on missing artifacts +- Provide clear visual feedback on why a step is disabled +- Example dependency chain: + - `/ideate` must complete and generate `rfe.md` + - `/spec` requires `rfe.md` to exist before it can run + - `/plan` requires spec artifacts before it can run +- Display artifact status indicators for each step + +### [Actionable] Workflow Status Message Updates (Version 1 Feedback) +**Issue**: The workflow descriptions in each step should change to status messages when the step is running. For example, when a user runs /ideate then 'Create or update rfe.md file' should become 'Generating rfe.md'. + +**Component**: Workflow UI, step status display + +**Action Required**: +- Implement dynamic status message updates during execution +- Replace static descriptions with active status messages when running +- Examples: + - Before: "Create or update rfe.md file" + - During: "Generating rfe.md..." + - After: "Generated rfe.md" (with timestamp) +- Use progressive verb forms during execution ("Generating", "Creating", "Analyzing") +- Add visual indicators (spinner, progress bar) alongside status messages +- Persist completion messages after step finishes + +### [Actionable] Separate RFE and Specification Workflows (Session 2 - Dana Gutride, Gage Krumbach) +**Issue**: The current workflow conflates RFE (for PMs) and Specification (for engineers). These should be distinct workflows for different user types. + +**Timestamp**: 00:27:42 - 00:31:23 + +**Component**: Workflow design, user flows + +**Action Required**: +- **PM Workflow**: Focus on iterating on ideas/RFEs + - PMs should primarily work on the "Idea" (formerly RF.md) + - After PM completes idea, they trigger a "Generate Specification" workflow + - PM workflow should be a guided journey with prompts and questions, not manual commands +- **Engineer Workflow**: Starts from a completed specification + - Engineers receive the spec.md output from the PM workflow + - Engineers can then run spec kit commands themselves if needed + - Engineers are "power users" who can run specific commands +- Create clear handoff point between PM idea generation and engineering specification +- Don't teach PMs spec kit - they just iterate on ideas +- Engineers need to understand spec kit for refinement + +**User Types Identified**: +1. **Power Users** (Engineers): Run specific commands, need full control +2. **Workflow Runners** (PMs): Taken through guided journey, don't need command-level access + +### [Actionable] Bot-Guided Repo Setup (Session 2 - Bill Murdock) +**Issue**: The form-based spec repo setup is cumbersome. The chatbot should guide users through this process. + +**Timestamp**: 00:21:43 + +**Component**: Spec repo configuration, chat interface + +**Action Required**: +- Move spec repo setup into chat-based flow +- Let the chatbot ask for GitHub username and personal access token through conversation +- Bot can intelligently guide the user: "I need access to your GitHub repos. Please provide your GitHub username and a personal access token" +- Bot can be smarter about validation (e.g., not requiring `.git` suffix) +- Reduce friction compared to traditional form fields + +--- + +## Workflow Design Philosophy + +### [Actionable] Generic Workflow Platform Approach (Session 2 - Andy Braren, Gage Krumbach, Bill Murdock) +**Issue**: The platform is being designed too specifically around RFE creation. It should be a generic workflow platform. + +**Timestamp**: 00:37:06 - 00:39:05 + +**Component**: Overall platform design philosophy + +**Action Required**: +- Stop positioning this as an "RFE builder" +- Position as a **generic workflow platform** where teams can define and run whatever workflows they want +- The "Create RFE" workflow is just the first example/use case +- Teams should be able to: + - Define their own workflow steps + - Customize artifact names and formats + - Use different integrations (not just Jira) + - Adapt the platform to their team's processes +- Ensure UI and documentation reflect this generic, flexible approach +- Consider creating a workflow editor/builder for future phases + +**Design Principle**: +> "We're making a generic platform to help users and help internal teams run whatever workflows they desire, augmented by AI. The RF workflow is just the first stab at that." + +--- + +## Open Questions & Discussion Items + +### [Needs Clarification] File Editing in UI (Version 1 Feedback) +**Question**: Do we need file editing in the Ambient Code UI for MVP? + +**Context**: Determining scope for MVP release + +**Discussion Points**: +- What types of files would users need to edit? +- Can users edit artifacts (rfe.md, spec.md, etc.) directly in the UI? +- Is read-only view sufficient for MVP? +- Should editing be delegated to external editors/IDEs? +- What's the expected workflow: view → edit externally → re-upload? + +**Status**: Needs product/design review + +### [Needs Clarification] Artifact Storage Architecture (Version 1 Feedback) +**Question**: Can we abstract the idea of a spec repo for artifacts and config, or can we have a default storage area on the container we are running in? + +**Context**: Determining artifact storage strategy + +**Discussion Points**: +- Current approach uses separate "spec repo" for artifacts +- Alternative: Default storage on job container filesystem +- Pros of spec repo: Version control, collaboration, persistence +- Pros of container storage: Simpler setup, no git dependency +- Hybrid approach: Default to container, optional git sync +- Impact on artifact sharing across sessions +- Impact on artifact versioning and history + +**Status**: Needs architecture review + +### [Needs Clarification] Collaboration Features (Version 1 Feedback) +**Question**: How should collaboration work in workflows? + +**Context**: Multi-user workflow participation + +**Discussion Points**: +- Can multiple users work on the same workflow simultaneously? +- How are conflicts resolved when multiple users edit artifacts? +- Do we need real-time collaboration (like Google Docs)? +- Is async collaboration (like GitHub PRs) sufficient? +- How do permissions work for shared workflows? +- Should workflows be owned by projects or individual users? + +**Status**: Needs product/design review + +### [Needs Clarification] Artifact Iteration Through Chat (Session 2 - Bill Murdock, Sally O'Malley) +**Question**: Can users iterate on generated artifacts through chat instead of manual file editing? + +**Timestamp**: 00:41:09 - 00:43:43 + +**Context**: User workflow preference + +**Resolution**: This already works! Users can iterate on artifacts (RF.md, spec.md) through the chat interface while the session is alive. + +**Action**: +- Ensure this capability is prominently documented +- Make it clear in the UI that artifacts can be refined through conversation +- Example: After RF.md is generated, user can say "Remove the stuff about WAGG 2.1, I don't think that's appropriate" + +**Status**: Feature exists, needs documentation/visibility + +### [Future Enhancement] Artifact Viewer in Right Sidebar (Session 2 - Andy Braren) +**Issue**: It would be helpful to preview generated artifacts without leaving the interface. + +**Timestamp**: 00:42:08 + +**Context**: Emerging pattern in Claude web interface, Cursor, and other AI tools + +**Proposal**: +- Add artifact browser/viewer in right-hand sidebar +- After generating artifacts, users can click on one to see preview +- Could show live PR, code files, or markdown preview +- Follows pattern emerging in modern AI interfaces + +**Priority**: Future enhancement, not MVP + +**Status**: Document for future consideration + +### [Future Enhancement] Auto-Create Spec Repo (Session 2 - Bill Murdock) +**Issue**: Requiring users to manually create a spec repo adds friction. + +**Timestamp**: 00:23:38 + +**Proposal**: +- If user doesn't already have a spec repo, the system could create one for them +- Currently: User must create empty GitHub repo, then seed it +- Future: System creates the repo and seeds it in one step + +**Priority**: Nice to have, not MVP critical + +**Status**: Document for future consideration + +### [Future Enhancement] Workspace/Team Hierarchy (Session 2 - Andy Braren) +**Issue**: Need another organizational level above projects for PM teams to collectively manage workflows. + +**Timestamp**: 00:52:59 - 00:54:04 + +**Context**: PM teams need shared workflow definitions + +**Proposal**: +- Add "Workspace" or "Team" level above projects +- PM team could collectively own and edit the "Create RFE" workflow definition +- Workflows defined at workspace level are available to all projects in that workspace +- Enables team-wide workflow management + +**Priority**: Phase 2 feature + +**Status**: Document for future architecture planning + +--- + +## Summary of Actionable Items + +**High Priority** (Session 2 additions marked with 🆕): +1. Remove Workflows from project page navigation (Version 1) +2. Hide API Keys from project view until Jira integration (Version 1) +3. Move Project Info to overview page (Version 1) +4. Implement workflow step dependencies based on artifact generation (Version 1) +5. Add dynamic status messages for workflow steps (Version 1) +6. 🆕 Remove "Headless Session" option - all sessions are interactive (Session 2) +7. 🆕 Rename "RF.md" to "Idea.md" throughout UI (Session 2) +8. 🆕 Add spec repo education tooltip/popup (Session 2) +9. 🆕 Move Integrations to user menu (Session 2) +10. 🆕 Improve agent selection UI - show auto-select as default (Session 2) +11. 🆕 Separate RFE and Specification workflows for different user types (Session 2) +12. GitHub integration access control review + +**Medium Priority**: +13. 🆕 Bot-guided repo setup through chat (Session 2) +14. 🆕 Generic workflow platform positioning (Session 2) +15. Clarify "Associated Repository" terminology +16. Session vs Workflow terminology clarity +17. Project Information tab content evaluation (after moving to overview) +18. Live markdown rendering implementation + +**Low Priority / Needs Discussion**: +19. Task popup suggestions (requires design review) +20. File editing in UI for MVP (requires product review) +21. Artifact storage architecture (requires architecture review) +22. Collaboration features design (requires product review) + +**Future Enhancements** (Document but defer): +23. 🆕 Artifact viewer in right sidebar (Session 2) +24. 🆕 Auto-create spec repo (Session 2) +25. 🆕 Workspace/Team hierarchy above projects (Session 2) + +--- + +## Notes for AI Agents + +When implementing changes: +- Follow vTeam frontend standards in `components/frontend/DESIGN_GUIDELINES.md` +- Use Shadcn UI components only +- Ensure TypeScript strict mode compliance (no `any` types) +- Add loading and error states for all new features +- Update tests and documentation +- Follow the backend standards in `CLAUDE.md` for Go changes diff --git a/static-prototype/design_path/prototype_version_1_feedback/my_notes.txt b/static-prototype/design_path/prototype_version_1_feedback/my_notes.txt new file mode 100644 index 000000000..852e4b138 --- /dev/null +++ b/static-prototype/design_path/prototype_version_1_feedback/my_notes.txt @@ -0,0 +1,18 @@ +Feedback on Version 1 of the Ambient Code prototype + +Actionable + +- Hide workflows from the project view +- Hide API keys from the project view for now until we have Jira integration +- Move Project info to overview page +- Each step in a workflow depends on the successful completion of the step before it. For example if the /spec command needs /ideate to have successfully run. A successful run of a step is determined by weather or not it generated an artifact. For example if there is no rfe.md generated then /spec is disabled. +- The workflow descriptions in each step should change to status messages when the step is running. For example when a user runs /ideate then ‘Create or update rfe.md file’ should become ‘Generating rfe.md’ + +Needs further discussion + +- Open question: File editing the ambient code UI, do we need it for MVP? +- Open question: Can we abstract the idea of a spec repo for artifacts and config or can we have a default storage area on the container we are running in? +- Open question: Collaboration + + + diff --git a/static-prototype/design_path/prototype_version_1_feedback/plan.md b/static-prototype/design_path/prototype_version_1_feedback/plan.md new file mode 100644 index 000000000..949907362 --- /dev/null +++ b/static-prototype/design_path/prototype_version_1_feedback/plan.md @@ -0,0 +1,766 @@ +# Static Prototype Update Plan + +This plan outlines concrete changes to the static prototype HTML files to address actionable feedback from curated_feedback.md. + +**Last Updated**: After Session 2 feedback integration + +**New Updates from Session 2**: Updates 8-13 added below + +## Files to Modify + +### Core Project Pages +- `static-prototype/projects/sample-project/page.html` - Main project page with sidebar navigation +- `static-prototype/projects/sample-project/info/page.html` - Project information page +- `static-prototype/projects/sample-project/rfe/page.html` - RFE Workspaces page (workflow page) +- `static-prototype/projects/sample-project/sessions/page.html` - Sessions list page +- `static-prototype/projects/sample-project/keys/page.html` - API Keys page +- `static-prototype/projects/sample-project/permissions/page.html` - Permissions page +- `static-prototype/projects/sample-project/settings/page.html` - Settings page + +### Individual RFE/Workflow Pages (examples) +- `static-prototype/projects/sample-project/create-api-tests/page.html` +- `static-prototype/projects/sample-project/implement-login-flow/page.html` +- Other workflow instance pages + +--- + +## Update 1: Remove Workflows from Sidebar Navigation + +**Priority**: High + +**Files**: All project pages (page.html, sessions/page.html, rfe/page.html, keys/page.html, permissions/page.html, settings/page.html, info/page.html) + +**Changes**: +1. In each file's sidebar (`