Resource Center

Clear Measure provides resources to empower software leaders and developers in software delivery, fulfilling our vision to improve and inspire software teams worldwide.
There is a version of AI adoption that most engineering organizations are living right now: tools get approved, some gains show up, gains plateau, and the conversation shifts to which tools to try next.  Then there is a different version. A project scoped for 26 weeks completes in 6. A labor budget of $875,000 delivers for $202,000. Defect prevention reaches 99%. ROI is realized within 21 weeks of go-live.  The difference between these two outcomes is not which tools the team used. It is what the delivery environment was built to do. Not sure what an AI Software Factory actually looks like in practice? Watch Jeffrey break it down in under two minutes.

Coding Is No Longer the Constraint 

Since Clear Measure's founding, the approach has been to front-load automation that drives quality and stability. The goal has always been to make the computer do all the work that it can.  With today's AI capabilities, even more work can be delegated safely to machines. Tasks that once took significant time no longer do. Coding is no longer the primary constraint.  That puts the focus where it belongs: architecture, strategy, and judgment.  AI isn't the strategy. It's a force multiplier when paired with discipline.  The teams still treating AI as a coding accelerator are missing the larger shift. When coding is largely automated, the constraint moves upstream to architecture and design. Teams can focus more on doing the right things for the customer market rather than on the mechanics of producing code.   

The Pattern Behind Every Major Engineering Shift 

Over time, Agile adoption led us to work in smaller batches. DevOps led us to automate the complete flow from software builds to the customer.  The AI Software Factory is the next step in that progression. It pulls automation from builds and deployments into every activity of software delivery and extends telemetry to the full process as well.  An AI Software Factory is a system that increases software delivery throughput while maintaining very high quality. It is an executive-level architecture pattern that empowers business executives to oversee software organizations. It enforces quality, stability, and speed while leveraging AI to automate repetitive work. It produces metric-based project scorecards daily and weekly so that executives know what is happening and can tune the organization.  This ensures software is delivered consistently to production in a visible way. Automation, scorecards, and guardrails provide clarity on quality, stability, and progress, so AI accelerates delivery instead of increasing risk.   

What AI Software Factory Produces 

The outcomes from a properly implemented AI Software Factory are specific and measurable:  77% reduction in project delivery timeline. A project scoped for 26 weeks completes in 6. The same scope, the same requirements, a fraction of the calendar time.  99% defect prevention rate. Up from the 95% industry baseline. Defects are caught automatically before they reach production rather than being discovered by users after the fact.  100% ROI within 21 weeks of go-live. A project that would have required $875,000 in labor delivers for $202,000, approximately $673,000 in savings. Measured against a typical implementation investment, those savings produce a full return within 21 weeks.  These are not projections. They come from building the delivery environment correctly: quality automation, repeatable deployment, architectural discipline, and AI-embedded throughout rather than bolted onto the end.   

Higher Throughput Without Higher Risk 

AI-driven development builds on Agile, DevOps, and test-driven development. It enhances and accelerates the software engineer’s workflow and inner loop.  AI tools can generate code, run private builds, and execute full test suites, but only inside disciplined guardrails and environments designed for it. AI agents don't bypass quality gates or push code unless everything passes.  That is what separates using AI tools from practicing AI-driven development: higher throughput without higher risk.  AI-driven development is the practice of modern software engineering to produce sustainable results. It separates the engineers from the vibe coders.  We don't lead with tools. We lead with outcomes. AI becomes part of how the team works, with discipline, not improvisation.   

What This Means for Your Team 

AI is a tremendous automation tool for software-enabled companies. It is not a tool designed to reduce or eliminate software engineering jobs.  Adopting AI does not immediately shrink engineering teams. What it does is enable companies to compete more aggressively. With AI, software teams can get more done, faster, and with higher quality. You can deliver more value, respond to the market more quickly, and grow.  As organizations grow, each software team member gets more leverage. You are able to accomplish far more per person than before. Over time, labor decreases when measured as a percentage of total revenue. But that is not because jobs were eliminated. It is because growth was enabled.  AI expands what your teams are capable of. It empowers engineers instead of replacing them.  Concerned about what AI means for your engineering team? Jeffrey addresses it directly.  

See It in Motion 

If you want to see the AI Software Factory working end-to-end before evaluating whether it is relevant to your organization, Clear Measure recently hosted a live demonstration. Real work items, real automation, real delivery metrics updating in real time. Watch the recording here.  For a walkthrough tailored to your specific stack and starting point, live demo sessions are available and kept small for actual conversation.   

The Starting Point 

The fastest way to understand where your organization stands relative to this architecture is the Clear Measure AI DevOps Inspection, a structured evaluation of your current delivery environment across every dimension that determines AI adoption readiness.  It produces a concrete roadmap: what is already working, what gaps exist, and what to address first to unlock the outcomes the AI Software Factory makes possible.   

In Summary 

The direction the industry is heading is clear. Business software will increasingly be designed by engineers and architects, with AI handling the construction. The organizations building those disciplines now will be the ones leading when it becomes the standard.   
This builds on our AI Software Factory demonstrations that we have already done. For implementing the AI Software Factory pattern in your organization, the first objective is Clarity. That starts with measurement. If we believe that AI automation will help software delivery, we need measurements in place to give us visibility into the success of the AI implementation. Join us to learn how to start measuring and reporting on software delivery throughput, as well as DORA metrics and others.

Jeffrey Palermo, CTO & Chairman of Clear Measure, presented the AI Software Factory, an executive-level architectural pattern for orchestrating software delivery from idea to production. He opened by addressing a core problem: software delivery has become the constraint in most organizations, and teams can't simply work faster when defects and production incidents are constantly consuming capacity. Poorly engineered AI adoption doesn't solve this, it just ships bugs faster. The AI Software Factory is the next evolution following Agile, DevOps, and cloud adoption, orchestrating people, processes, and automation across the entire delivery lifecycle.

A key theme throughout was that visibility must come before automation. Using a live Kanban board demo and a real client project, Jeffrey showed how a weekly scorecard tracking throughput, mean time to delivery, escape defects, and production incidents reveals bottlenecks and process gaps that would otherwise stay hidden. From there, AI automation is introduced intentionally, starting with simple, low-risk tasks, and always measured against the scorecard to confirm real improvement. Clear Measure's goal is to help organizations build software delivery systems that safely exploit AI without destabilizing their business.

A production support team at a digital-first insurance company was spending significant time on repetitive manual tasks like resolving import failures, investigating logs, and refining tasks. These issues occurred multiple times per week, with import failures taking about an hour each, log investigations around two hours per incident, and task refinement requiring several developer hours weekly. This limited their ability to focus on higher-value work, and AI adoption across teams was initially limited.

Clear Measure helped address these challenges by introducing Cursor for repeated tasks, sharing skills and workflows with the team, and providing training for developers, team leads, BSAs, and QA. Time was also allocated to rebuild workflows using Cursor. As a result, the team saw major efficiency gains: import failures dropped to about 15 minutes, log investigations to around 20 minutes, and task refinement to 1–2 hours per week. Issue investigation time decreased, several production issues were resolved the same day, and AI adoption continued to grow across the organization.

The AI knowledge gap is why most engineering teams aren’t seeing results.

AI budgets are up, but under scrutiny to show real & measurable business results. Expectations are high, especially given the AI hype. And yet most teams are not delivering the improvements and productivity gains of leadership expected when they approved those investments. 

The issue isn’t the technology.

It’s how teams are set up to use it.

  AI Doesn't Fix a Broken Delivery System. It Exposes One. The organizations that capture real value from AI are not the ones that moved fastest to adopt tools. They're the ones who had strong engineering fundamentals in place before AI entered the picture, including fast CI pipelines, automated testing, stable deployments, and real observability.  When those foundations exist, AI accelerates everything. When they don't, AI adds noise. Developers spend time managing tool outputs instead of shipping features. Pilots stall. Leadership loses confidence. ROI never materializes.  More spending on AI tools does not automatically create more value. What creates value is building the system around AI intentionally, starting with quality and stability, and treating automation as something you earn, not something you install.    The Missing Investment Is in Your People The tools are not bottlenecked. Your engineers are being handed AI-powered coding assistants and asked to figure it out. Most organizations have not built a learning environment, workflow integration, or clear standards that would allow their teams to use these tools effectively and confidently.  The result is exactly what you'd expect: some engineers find ways to make AI work for them; most don't, and the augmented capabilities of leadership expected never show up across the team.  Closing this gap requires deliberate investment in your people and not just licenses and subscriptions, but structured training, peer learning, and a delivery framework that ensures AI adopts a system-level capability rather than an individual experiment.  That's where Clear Measure can help.    Three Ways to Upskill Your Engineering Leaders AI Software Architect Forum (Online, Monthly) The monthly AI Software Architect Forum is a peer-led conversation guided by The Five Pillars, to help engineering leaders with the real challenges of AI adoption, team performance and software delivery.  Led by Jeffrey Palermo, Clear Measure's Chief Architect and a 13-time Microsoft MVP, this is a place for candid discussion with peers who are navigating the same decisions you are. No vendor pitches. No slides. Just a focused conversation about what is actually working.  Register for the Next Forum →    Advanced .NET Bootcamp — Immersive In-Person Training For teams ready to go deep, the Advanced .NET Bootcamp is three days of hands-on, practitioner-led training covering modern .NET architecture, DevOps fundamentals, and AI-driven development.  This bootcamp teaches the attendees how to build a delivery system that AI can actually improve. The curriculum covers the engineering fundamentals that make AI adoption stick, including CI architecture, automated testing, stable deployments, observability, and then layers in AI-driven development once that foundation is solid. Your engineers and lead architects leave knowing not just how to use AI tools, but where to apply them, how to measure whether they're working, and how to keep quality from slipping as automation increases.  "The AI portion of the Advanced .NET Bootcamp has been especially valuable. It's practical and grounded in real workflows, which matters in a fast-moving space where hype is everywhere." — Bootcamp Attendee  Contact Us to Learn More About the Bootcamp →    Want to See What a Mature AI Delivery System Looks Like? If your team is evaluating how to build AI into your software delivery process, not just into individual workflows, then our AI Software Factory demo is worth an hour of your time. Jeffrey walks through a live system: real work items, real automation, real delivery metrics update in real time. These Sessions are kept small and meant for actual conversation about your stack and your starting point.  Schedule a Demo Session →    The organizations winning with AI right now are not the ones who spent the most. They're the ones who treated AI as an end-to-end system problem, not a tooling problem, and those who built the delivery foundations first, trained and upskilled their people deliberately, and measured every automation decision against real outcomes.  That's the work Clear Measure does. We don't sell AI tools. We help engineering teams build the system around them, one that can absorb and truly leverage AI intentionally, scale it responsibly, and show up in your delivery metrics. 
TL;DR — Move dozens of repositories to a high-speed DevDrive in minutes using GitHub Copilot CLI (powered by Claude Haiku 4.5) and transparent Windows symbolic links. Zero tool configuration changes needed.
Why Migrate to DevDrive? Windows DevDrive is a specialized volume format that provides dramatic performance improvements for development workloads:
  • ~40% faster Git operations
  • ~25% faster build times
  • ~30% faster file I/O operations
  • Optimized for development patterns (many small files)
  • Transparent — existing tools work without configuration changes
If you're managing dozens of source repositories, moving them to a DevDrive can shave significant time off your daily development cycle. Prerequisites Before starting, ensure you have:
  • Windows 11 or Windows Server 2022 (DevDrive requires recent Windows versions)
  • Administrator privileges (required for DevDrive creation and symbolic links)
  • At least 150-200 GB free space (depending on your codebase size)
  • GitHub Copilot CLI installed (winget install GitHub.Copilot.CLI or download from github.com/copilot)
  • PowerShell 7+ (recommended) or Windows PowerShell 5.1+
Check Your Windows Version # Verify you're on Windows 11 or Server 2022 [System.Environment]::OSVersion.VersionString # You should see something like: # Microsoft Windows NT 10.0.26100.0 Step 1: Create a New DevDrive Option A: Using Windows Settings (GUI)
  1. Open Settings → System → Storage
  2. Scroll down to find Advanced storage options
  3. Click "Disks & volumes" (or "Dev drives" depending on your Windows version)
  4. Look for unallocated space on your secondary drive (in this example, the D: drive)
  5. Click "Create a Dev drive" button
  6. Configure the DevDrive:
    • Location: Select your secondary drive (e.g., D:)
    • Size: At least 150-200 GB for typical development workloads
    • Label: Name it something descriptive like "DevDrive-Projects" or "DevDrive-Repos"
  7. Click "Create" and wait 2-5 minutes for initialization
Option B: Using PowerShell (Command Line) # Requires Administrator privileges # Run as Administrator! # Create a 200 GB DevDrive on D: with label "DevDrive-Repos" New-DevDrive -Drive D: -Size 200GB -Name "DevDrive-Repos" # Verify creation Get-Volume | Where-Object { $_.FileSystem -eq "DevFS" } # You should see your new DevDrive listed ⏱️ Time: 2-5 minutes for DevDrive initialization Step 2: Open GitHub Copilot CLI GitHub Copilot CLI automates the entire migration process. Launch it: copilot Step 3: Run the Migration Prompt Copy and paste this prompt into Copilot CLI (adapt the paths and repository count to your setup):
I have lots of repositories in C:\Users\YourUsername\source\repos and I want this path to have a virtual link to my new DevDrive at D:\. I want all the subfolders moved to D:\ and the paths to have virtual links so that old references to C:\Users\YourUsername\source\repos get redirected to D:\ instead, so that tools like Git, VSCode, and Visual Studio continue working without any configuration changes.
Replace:
  • YourUsername with your Windows username
  • D:\ with your DevDrive path (if using a different letter)
Press Enter and let Copilot CLI handle the rest. Copilot CLI Response The CLI will analyze your request and create a structured plan: 🔍 Analyzing your setup... 📋 Creating implementation plan... PLAN CREATED: ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Problem: Migrate repositories (~85 GB) from C:\Users\YourUsername\source\repos to DevDrive (D:\) while maintaining backward compatibility Approach: 1. Create a symbolic link at C:\Users\YourUsername\source\repos → D:\ 2. Move all repositories from C:\Users\YourUsername\source\repos to D:\ 3. Verify all paths resolve correctly 4. Test Git operations through the symbolic link Strategy: ✓ Single directory link (more maintainable than individual links) ✓ Target layout: All repos directly under D:\ (D:\repo-name structure) ✓ Backward compatibility: Old paths continue working transparently Ready to proceed? (Type 'start' to begin migration) Step 4: Watch the Automated Migration Type start to begin: start Copilot CLI will execute the migration in phases: Phase 1: Pre-Migration Validation === PHASE 1: PRE-MIGRATION VALIDATION === ✓ Source directory exists ✓ DevDrive (D:\) exists ✓ Source size: 85.27 GB ✓ D:\ free space: 252.65 GB ✓ Sufficient space available ✓ Path is a regular folder (ready for conversion) ✓ No open handles detected === PHASE 1 COMPLETE === What it checks:
  • Source and target paths exist
  • Sufficient free space
  • No open file locks
  • Permissions are correct
Phase 2: Migration === PHASE 2: MIGRATING REPOSITORIES === Found N repositories to migrate Using Robocopy for efficient migration with resume capability... Moving: project-api ✓ Success Moving: framework-core ✓ Success Moving: webapp-frontend ✓ Success ... Moving: infrastructure-tools ✓ Success === PHASE 2 SUMMARY === Successfully migrated: N Failed migrations: 0 === PHASE 2 COMPLETE === 📊 Migration Details:
  • Method: Robocopy (fast, resumable, maintains file attributes)
  • Time: 6-8 minutes for 85 GB (varies by drive speed)
  • Reliability: Automatic retry on failure
Phase 3: Create Symbolic Link === PHASE 3: CREATING SYMBOLIC LINK === Creating symbolic link... Source: C:\Users\YourUsername\source\repos Target: D:\ ✓ Symbolic link created successfully ✓ Symbolic link verified! === PHASE 3 COMPLETE === What happens:
  • Removes empty source directory
  • Creates Windows directory junction using mklink /J
  • Verifies link points to correct target
Phase 4: Verification === PHASE 4: VERIFICATION & TESTING === 1. Testing path redirection... Old path: C:\Users\YourUsername\source\repos Points to: D:\ ✓ Verified 2. Listing repositories via old path... Found N repositories ✓ Path is accessible 3. Listing repositories via new path (D:\)... Found N repositories 4. Verifying consistency... ✓ Repository counts match 5. Testing file access through old path... Sample repo: sample-project ✓ Can access files === PHASE 4 COMPLETE === Phase 5: Tool Compatibility Testing === PHASE 5: TESTING TOOL COMPATIBILITY === Testing Git Integration... Found Git repo: sample-project Testing 'git status' via old path... ✓ Git commands work through symbolic link Testing Absolute Path Access... C:\Users\YourUsername\source\repos\sample-project ✓ Accessible D:\sample-project ✓ Accessible === PHASE 5 COMPLETE === Step 5: Verify Everything Works That's it! Copilot CLI handles the entire migration automatically. To verify everything works, test with your tools: Test 1: Git Operations cd C:\Users\YourUsername\source\repos\sample-project git status Test 2: Open in IDE
  • VSCode: code C:\Users\YourUsername\source\repos\sample-project
  • Visual Studio: File → Open → navigate to old path
  • Rider: File → Open → select old path
Test 3: Build Operations cd C:\Users\YourUsername\source\repos\my-dotnet-app dotnet build ✅ All should work without any configuration changes. Understanding Symbolic Links How It Works Windows symbolic links (directory junctions) create a transparent redirect: Application Request ↓ C:\Users\YourUsername\source\repos ↓ [Windows Kernel: This is a junction to D:\] ↓ D:\ ↓ Actual Files & Directories Why It's Safe
  • Transparent — Applications don't know about the redirect
  • Reliable — Windows handles it at the kernel level
  • Performant — Negligible overhead
  • Recoverable — Data remains on D:\ unmodified
  • Tested — Used extensively in Windows and NTFS
Performance Improvements Once migrated, you'll see performance gains in development workflows: Benchmark: Before vs After Operation Before (C: SSD) After (DevDrive) Improvement Git clone (2 GB repo) 45 seconds 28 seconds ~38% faster Git status (1000 files) 2.3 seconds 1.8 seconds ~22% faster dotnet build 35 seconds 26 seconds ~26% faster npm install 18 seconds 13 seconds ~28% faster File enumeration (500K) 4.2 seconds 2.8 seconds ~33% faster Results vary based on disk hardware and repository size Troubleshooting Issue: "Access Denied" on Symbolic Link Creation Solution: Run PowerShell as Administrator (Right-click → "Run as administrator") Issue: "Insufficient Space" Error Solution: Check DevDrive size and ensure you have free space $drive = Get-Volume -DriveLetter D $freeGB = [math]::Round($drive.SizeRemaining / 1GB, 2) Write-Host "Free space on D:\: $freeGB GB" Issue: Some Repositories Fail to Migrate Solution: Close all applications accessing the repositories (IDEs, VSCode, file explorers, Git tools, antivirus) and retry. Resources Summary: Your Migration Checklist
  • Verify Windows 11 or Server 2022 version
  • Create new DevDrive (150-200 GB)
  • Install GitHub Copilot CLI
  • Open Copilot CLI: copilot
  • Paste migration prompt (customize for your paths)
  • Review generated plan
  • Type start to execute
  • Wait for migration to complete (6-8 minutes)
  • Test with Git: git status
  • Test with IDE: Open project in VSCode/Visual Studio
  • Done! Enjoy 25-40% performance improvements
Rollback (If Needed) If you need to reverse the migration: # 1. Remove the symbolic link rmdir "C:\Users\YourUsername\source\repos" # 2. Move repositories back from D:\ (all data remains intact)
Conclusion Migrating your development repositories to a Windows DevDrive is a low-risk, high-reward operation. Using GitHub Copilot CLI powered by Claude Haiku 4.5, you get:
  • Automated migration in 3 simple steps (create DevDrive, open CLI, paste prompt)
  • Zero tool configuration changes via symbolic links
  • Performance gains of 25-40% on typical operations
  • Backward compatibility — existing paths continue working
  • Transparent redirection at the OS level
  • AI-powered automation — Claude Haiku handles all complexity
In just 15-20 minutes (including DevDrive setup and verification), you can achieve sustained performance improvements across your entire development workflow—all powered by Copilot CLI and Claude Haiku 4.5. 🚀 Happy coding on your faster DevDrive!

Hear directly from past attendees of Clear Measure's Advanced .NET Bootcamp — a 3-day, immersive in-person training taught by Jeffrey Palermo, designed for software engineers and architects who want to sharpen their skills and deliver better software, faster.

The bootcamp covers modern .NET architecture, DevOps practices, cloud transformation, application modernization, AI-driven development, and more — with hands-on exercises throughout each day. Ready to level up your team?

Learn more and enroll: https://clearmeasure.com/trainings/workshops/advanced-net-bootcamp/ Questions? Email us at info@clear-measure.com

Industry Veteran with 35-Year Career in Technology Services Joins to Lead New Business Sales and Market Expansion

Monday, April 13, 2026 — Clear Measure announced the appointment of Richard Sobota as Vice President of Strategic Growth. In this role, Sobota will lead the company's new business sales efforts, build new client relationships, and help drive Clear Measure's next phase of revenue growth. At Clear Measure, Rich will report to Jeffrey Palermo and focus on driving new client growth and expanding the company’s market reach.

Sobota brings more than 35 years of experience in technology services, digital transformation, and enterprise solution delivery. He has held senior leadership roles at Accenture, IBM, Capgemini, and Cognizant, where he built a strong track record of leading complex pursuits, developing strategic client relationships, and helping organizations modernize and grow through technology.

His experience spans cloud transformation, application modernization, data and artificial intelligence, enterprise platform deployments, and large-scale managed services engagements while delivering real results for many of the world's leading organizations across retail, consumer products, travel, and the public sector.

Before his industry career, Sobota graduated from the United States Air Force Academy and served as a systems engineer and intelligence officer. He is known for combining executive-level relationship building with a practical, customer-first understanding of how technology creates business value.

At Clear Measure, Sobota will lead sales and help more clients understand the value the company brings through custom software, modern engineering practices, and business-focused technology solutions.

Contact: Richard Sobota richard.sobota@clear-measure.com
The promise of AI in software development is that it will profoundly increase the rate of software delivery. But merely using AI tools does not deliver on that promise. Putting together an end-to-end automated process is what's required. That is the pattern of the "AI Software Factory". In this webinar, you will see an AI Software Factory in motion and learn what you need to do to implement this pattern for yourself to 2x and 3x your pace of software delivery.

Filters

The Five Pillars
The Five Pillars
Show more
Content Type
Content Type
Show more
Category
Category
Show more