Contact us

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.
Get In Touch With Us
Filters
ai software factory
Establish Quality
Blogs
AI

What the AI Software Factory Actually Produces

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.   
Read More
Optimize the Team
Blogs
AI

Close the AI Knowledge Gap Before You Invest More in AI

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. 
Read More
Create Clarity
Blogs
AI

Migrate Repositories to Windows DevDrive with Copilot CLI

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!
Read More
octopus deploy
Establish Quality
Blogs
Octopus Deploy

Octopus Deploy Migration Planning: How to Modernize Your Environment Without the Risk

One of our clients was spending five full days on every manual deployment — not because they lacked talent, but because their Octopus Deploy environment had never been properly assessed or updated since it was first stood up years earlier. Tentacles (Octopus's deployment agents) had accumulated. Integrations had drifted. And nobody had stopped long enough to ask whether any of it still made sense. If that sounds familiar, you're not alone. Aging, unexamined Octopus Deploy environments are one of the most consistent problems we see across enterprise teams in healthcare, financial services, insurance, energy, and beyond.

Here's how we help teams fix that — and what's possible on the other side.

 Phase I: Assessing Your Octopus Deploy Environment Before Migration When a client comes to us with an aging Octopus Deploy environment, we don't start by recommending an immediate upgrade. We start by looking carefully at what is already there. Our Octopus Deploy Migration Planning engagement — designed specifically for complex environments — gives teams a complete picture before a single migration step is taken. This includes:
  • Analysis of the existing Octopus Deploy instance — what version, what configuration, what integrations, what's working and what's fragile
  • Analysis of the software being deployed and the nature of the environments being deployed to (cloud, hybrid, on-prem)
  • Sequencing of major migration or upgrade steps so nothing falls through the cracks
  • Best practices recommendations tailored to your architecture
In Phase I, our team conducts a thorough technical analysis of the client's Octopus Deploy environment, assesses and prioritizes their existing application portfolio across multiple environments, evaluates future applications as candidates for migration, and produces a formal migration plan with documented steps and a timeline. Trying to determine whether to stay on-prem or move to the cloud? We will uncover the information you need to make a confident decision. The output of Phase I isn't just a document — it's the strategic foundation that makes Phase II possible without unnecessary risk. Phase II: Proof of Concept for Your Octopus Deploy Migration With the migration plan from Phase I, we move into Phase II: Proof of Concept Implementation. Rather than attempting a full migration all at once, we use the POC approach to validate assumptions, surface any environment-specific surprises, and demonstrate end-to-end success for one application before scaling. This single-application migration serves as the proving ground — testing the target Octopus Deploy environment setup, validating deployment pipelines, and building client team confidence in the approach. A well-run POC de-risks the broader migration, gives stakeholders something concrete to evaluate, and creates a replicable pattern your team can follow for every subsequent application. Phase III: Full Portfolio Migration with Octopus Deploy

Following Phases I and II, you'll have something most teams never start with: a validated migration pattern, a target environment that's been proven to work, and a team that has already done this once successfully. That changes everything about how the remaining portfolio gets migrated.

At that point, we'll present a full estimate for converting the remainder of your applications to Octopus Deploy. From there, you have options. Our team can execute the full migration on your behalf, or your team can take on the work directly with our experts advising alongside them. What doesn't change regardless of the path: your team will understand exactly how the work is done, with detailed documentation and hands-on advisement until they're fully confident managing the environment on their own.

Octopus Deploy Training: Up-Leveling Your Team for Long-Term Success

Deploying a new version of Octopus is only as valuable as your team's ability to use it well. That's why team enablement is built into every Clear Measure engagement — not treated as an afterthought.

We meet teams where they are. If your team is new to Octopus or needs to reset some ingrained habits, a focused 2-hour orientation gets everyone aligned quickly. For organizations ready to go deeper, a full day of platform engineering planning helps connect architecture decisions to long-term delivery goals. And for enterprise teams looking to build advanced expertise and deploy at scale, we offer pro-level training customized to your environment and roadmap.

As Clear Measure Chief Architect Jeffrey Palermo puts it: "There isn't anything Octopus can't deploy. But if automated DevOps is new to your team, make sure to plan your platform engineering properly. Empower your team to establish quality, achieve stability, and increase speed of delivery." Learn more about how we work with Octopus Deploy across industries and team sizes. What Our Clients Are Saying "It was taking our team five days to do a proper manual deployment, so I decided it was time to move automation to the next level. By increasing the utilization of Octopus Deploys automation features from 10% to 80%, the company has increased productivity by over 84%. Now we have more efficiency and accuracy. It's a completely different deployment experience." — SVP of Operations, Alphapoint "Our old method of deployments was cumbersome on our IT team, and required significant time and stress. Clear Measure helped us set up an Octopus Deploy configuration that allows us to initiate mid-day deployments, saving time we would have normally spent after-hours to do a deployment." — Frontier How Octopus Deploy Fits Into a Modern AI DevOps Architecture Upgrading Octopus Deploy is one piece of a larger picture. At Clear Measure, we view deployment tooling as a core component of a modern AI DevOps architecture: the interconnected system of pipelines, automation, feedback loops, and intelligence that allows engineering teams to deliver software reliably and rapidly.

When your Octopus Deploy instance is current, properly configured, and correctly integrated with your build servers and cloud environments, it becomes the foundation that makes AI-assisted delivery possible — automated validation, complete auditability, and the kind of deployment speed that lets engineers focus on architecture and innovation instead of firefighting. Without that foundation, even the best AI tooling has nothing reliable to build on.

To see what this looks like end-to-end, download our AI DevOps Architecture Poster — a print-ready reference designed for .NET and Azure engineering teams. Octopus Deploy Migration Results: Real Client Outcomes The numbers speak for themselves. In one engagement with a FinTech firm, new environments that previously took days to provision were up and running in 4 hours or less, features could be deployed on demand, and overall team productivity increased by 84%. Read the full case study: Optimized DevOps Roadmap to Deliver Faster Results In another engagement, a supply chain management company with over 200 employees eliminated tedious manual deployments entirely — gaining the flexibility to deploy mid-day without disruption, proactively catching errors before they reached production, and freeing their IT team from the after-hours grind that had become the norm. Read the full case study: Streamline Deployments and Reduce Cycle Time Both transformations started with the same foundational work — assessing what existed, planning the right path forward, and proving it out before scaling. The pattern holds across every industry we work in:
  1. Inspect the existing environment with honesty and rigor
  2. Plan the migration before touching anything
  3. Prove the approach with a contained POC
  4. Up-level the team to maximize their investment in Octopus Deploy
  5. Iterate through remaining applications with confidence
The result isn't just a newer version of Octopus Deploy. It's a team that understands their deployment platform, a pipeline that reflects current best practices, and an organization positioned to move faster with less risk. Start Your Octopus Deploy Migration Planning Today

If your team is running an older self-hosted Octopus Deploy instance and isn't sure where to start, the best first step is a clear-eyed look at what you actually have — an honest technical assessment that tells you where your environment stands, what risk is accumulating, and what a better future state looks like.

That's exactly what our Octopus Deploy Migration Planning engagement is designed to deliver. Explore our Octopus Deploy practice to learn more, or contact us to start the conversation.

Read More
software development
Establish Quality
Blogs
AI

AI-Driven Development vs. AI-Assisted Coding: What’s the Difference?

97% of developers now use AI coding tools. But using a coding assistant and running an AI-driven development environment are two very different things — and confusing them is costing teams quality, maintainability, and time.
When most engineering teams talk about "using AI in development," they mean a developer has GitHub Copilot installed. Suggestions appear as they type. Some are useful, some aren't. The developer accepts what looks right and moves on. That's AI-assisted coding. It's useful. It's also only one small piece of what AI-driven development actually is — and conflating the two is one of the most common mistakes teams make when trying to modernize their delivery process. The Distinction That Matters An AI coding assistant operates at the level of a single engineer writing a single file. It autocompletes functions, suggests variable names, and sometimes generates a block of boilerplate. The engineer is still responsible for every decision — the tool just types faster. An AI-driven development environment operates at the level of the entire delivery system. It changes how work is specified, how it's designed, how it's tested, how it's deployed, and how production health is monitored. The engineer's role shifts from authoring every line to reviewing, validating, and directing AI-generated output within a system designed to catch problems automatically.

AI-Assisted Coding

One tool. One engineer. One file. Autocompletes code inside the IDE. Speeds up authoring. The delivery system around it is unchanged — manual processes, manual testing, manual deployment.

AI-Driven Development

One system. Every phase. Full lifecycle. Automates requirements, design, code generation, testing, CI/CD, UAT, and production monitoring. The entire delivery system is built to support and validate AI-generated output.
"A coding assistant accelerates one engineer writing one file. An AI-driven development environment automates the system of delivering software."
Why the Confusion Exists — and Why It's Costly According to GitHub's 2024 State of the Octoverse, 97% of developers now use AI coding tools in some capacity. Adoption has become the norm. But adoption alone doesn't produce the results teams expect — and in many cases, it makes things worse. When AI coding tools are dropped into an existing delivery process without changing the system around them, the results are predictable:
  • Generated code reflects the inconsistencies of the existing codebase — at higher volume and faster pace
  • Defects that would have taken a human time to introduce now appear in bulk
  • Velocity increases short-term while technical debt accumulates invisibly
  • The codebase becomes harder to maintain, not easier
The challenge has shifted from whether to adopt AI to how to do it without accumulating technical debt, degrading maintainability, or losing architectural coherence. That shift requires thinking about AI as a delivery system problem — not a tooling problem. What AI-Driven Development Actually Covers A true AI-driven development environment automates work across every phase of the software delivery lifecycle. Here's what that looks like in practice:
Phase 1 Requirements & Specification Structured checklist templates and AI-generated specs replace unstructured discovery sessions. Analysts produce precise, machine-readable requirements that feed directly into technical design — no translation layer, no information lost.  
Phase 2 Technical Design Architecture patterns decompose requirements into development tasks automatically. Design becomes repeatable rather than ad hoc — every feature follows the same structural logic, which is exactly what makes AI code generation reliable downstream.  
Phase 3 Code & Test Generation LLMs generate implementation code and test scenarios directly from design specs. Engineers review, validate, and extend — they are no longer authoring from scratch. The quality of this output depends entirely on the quality of phases 1 and 2 feeding into it.  
Phase 4 CI/CD & Deployment Fully automated pipelines handle build, multi-level testing, environment provisioning, UAT promotion, and production deployment. Every change — regardless of how fast it was generated — moves through the same quality gates before it reaches a customer.  
Phase 5 Production Monitoring Telemetry is analyzed on a defined cadence — hourly, daily, weekly. AI surfaces anomalies and generates improvement suggestions automatically. The system doesn't just deliver software; it watches what happens after delivery and feeds that signal back into the process.
The Implication for Your Team If your team is currently using AI coding tools without this surrounding infrastructure, you have the first piece of a much larger system. The tools are not wrong — the context they're operating in is incomplete. The good news is that building the system is a structured process. It starts with establishing a consistent architectural foundation, adds automated quality gates and pipeline hardening, and then layers in AI-assisted generation on top of an environment designed to validate and deploy that output safely.

Want the Full Framework?

Clear Measure's AI-driven development methodology covers the complete lifecycle — from readiness assessment and architectural standardization through full pipeline automation and production telemetry. See the full technical guide →
The distinction between AI-assisted coding and AI-driven development isn't academic. It's the difference between a tool that speeds up one engineer and a system that transforms how an entire team delivers software. Understanding where you are on that spectrum is the first step toward building something better.
Not Sure Where Your Team Stands? Talk to a Clear Measure AI DevOps Architect. We'll assess your codebase, DevOps foundation, and delivery baseline and tell you honestly what your AI readiness looks like. Talk to an Architect
 
Read More
ai driven development
Increase Speed
Blogs
AI

AI Software Delivering More Value in Less Time

AI-driven software isn’t about replacing engineers—it’s about amplifying their effectiveness. By letting computers generate significant portions of code, projects can move at the pace of your ideas while using fewer manual hours. Work that would take an average developer two weeks of coding can be reduced to a single day with AI-driven development. This shift allows teams to deliver features quickly and with fewer people—creating better economics than traditional offshore development while avoiding communication gaps or delays.    To make that speed count, teams need to create clarity—clear goals, shared priorities, and a visible path. When everyone knows what’s being built, why it matters, and how success is measured, AI becomes a real accelerator instead of just a code generator.    This combination of AI-driven development and clarity allows teams to deliver features faster, reduce rework, and maintain high quality.  AI at Work in Software Builds  When specifications, UX details, technical design, and test plans are clear, AI tools can produce large portions of functionality in seconds. Engineers then refine and validate that output, ensuring the resulting software matches your standards and integrates cleanly into your systems.    Creating clarity early in these steps reduces confusion and rework later. By structuring work into well-defined stages—concept, design, implementation, validation, release—teams ensure AI is applied where progress stands and where AI fits best.    Unlocking New Economics  Organizations often think that outsourcing offshore is the only way to save on development costs. AI-driven development offers a different path—enabling teams to produce code faster, streamline processes, and reduce expenses, while maintaining high quality and reliable outcomes.    Smaller, well-scoped projects make that advantage even stronger. When the team understands the purpose and outcomes, AI-accelerated work stays focused, predictable, and aligned with business goals.    Features, Delivered Sooner  This planned approach accelerates delivery while freeing developers to focus on high-value work: defining the right features, improving user experience, and strengthening overall design.  Measuring what matters—quality, stability, speed, and outcomes—keeps everyone on the same page and builds trust. With clear metrics, AI-driven development doesn’t just move faster; it moves smarter.    Key Takeaways 
  • AI-assisted coding accelerates development cycles. 
  • Tasks that once took two weeks can now be completed in a single day. 
  • Projects can be delivered with fewer people, improving cost efficiency. 
  • Early detection and refinement minimize rework. 
  • Faster builds unlock innovative, intelligent features for your software. 
Read More
AI
Increase Speed
Blogs
AI

Transforming Software Architecture and Delivery Utilizing AI

AI-Driven Development is changing how software teams think about designing, building, and delivering applications. By embedding AI into the development process, teams can move faster, reduce repetitive work, and make better architectural decisions, creating software that is maintainable and reliable. AI is not about replacing intelligence; it is automation that helps us move faster, not think for us.

The Role of AI in Modern Software Development
AI takes on repetitive or time-consuming tasks such as generating code patterns, refactoring, or analyzing code for potential issues. It does not make people smarter; it helps experienced teams move faster and stay focused on higher-level architecture and design decisions. When developers know what they are doing, AI accelerates their work. When they do not, it exposes gaps. The value comes from speed and consistency, not from intelligence.

Architecture Meets AI
Strong software architecture remains essential for scalable and maintainable applications. AI-driven development works alongside architectural best practices by:

Improving scalability and performance: By analyzing code and dependencies, AI helps identify slow areas and improve system design.
Enhancing collaboration: Developers, testers, and architects can use AI outputs to stay aligned with architecture and implementation strategies.

AI processes what is given to it and performs pattern matching, not reasoning. Integrating it into architecture-focused workflows results in faster builds and cleaner designs, but the intelligence still comes from the people using it.

Practical Benefits of AI-Driven Development
Teams see clear advantages from AI-driven development:

Faster coding and iteration: AI automates repetitive coding work so teams can focus on architecture.
Proactive problem detection: Pattern analysis identifies issues early, reducing rework.
Better code quality: Consistent, AI-assisted reviews help keep systems clean and maintainable.

Unlocking the Future of Software Delivery
AI-driven development is not a trend; it is a practical evolution in how software is built. There is no real intelligence here; it is automation that speeds up what skilled teams already know how to do. Combining AI with solid architectural practices enables organizations to deliver faster, more reliable software without the hype, focusing on accurate and efficient execution grounded in expertise.

Read More
expense report
Increase Speed
Blogs
AI

Automate Expense Reports with .NET Agents & Azure AI

One of the most promising applications of generative AI in today’s enterprise landscape is automating business processes. These workflows often involve nuanced decisions and inconsistent or unstructured data, making them difficult to automate with traditional logic-based systems. In this post, we’ll explore how to build a .NET agent using Semantic Kernel and Azure AI Foundry to process employee expense reports based on natural-language policies. This is a practical, hands-on example of how large language models (LLMs) can be embedded into real business applications. To access the code, you can find it on github here. The Challenge: Processing Expense Reports Most organizations require employees to submit expense reports for reimbursement. These reports typically include:
  • A summary of expenses (meals, travel, lodging, etc.)
  • Receipts or supporting documents
  • Explanations or justifications
A human reviewer must then interpret the company’s expense policy to determine whether each report should be approved, denied, or escalated. Policies often contain natural-language rules like:
  • Meals must not exceed $75 per day
  • Receipts are required for expenses over $25
  • Travel must be pre-approved
  • Alcohol is not reimbursable
While these rules are easy for humans to understand, they’re tricky to encode in software. Limitations of Traditional Automation Legacy systems rely on structured input fields - dates, dropdowns, number boxes, etc. - to extract and validate data. These approaches struggle when inputs vary or include ambiguity. For example:
  • One user attaches a PDF receipt, another pastes in a screenshot
  • Justifications vary from bullet points to full paragraphs
  • Fields are left blank or inconsistently formatted
Maintaining and scaling these brittle rulesets is time-consuming and error-prone. What’s needed is a system that understands context and intent, not just structure. Enter .NET Agents with LLMs By combining Semantic Kernel with Azure-hosted language models, we can build a .NET agent that reads expense data, applies policy logic, and returns a clear recommendation - all using natural language. Benefits of this approach:
  • Works with inconsistent or unstructured input
  • Understands prose-style policies and nuanced reasoning
  • Returns human-readable summaries for transparency
Defining the Output: Recommendation Class We’ll start by defining a simple data structure to hold the agent’s recommendation. public class ExpenseReportRecommendation { public string EmployeeName { get; set; } = string.Empty; public DateTime ReportDate { get; set; } public decimal AmountReported { get; set; } public decimal ReceiptsTotal { get; set; } public string Recommendation { get; set; } = string.Empty; public string Summary { get; set; } = string.Empty; } The agent will use this class to report its findings - whether to approve, deny, or refer a report to a manager. Implementing the Tools Our agent will need access to two main tools:
  1. A function to retrieve the employee’s expense report
  2. A function to retrieve the current expense policy
Here’s the function to retrieve the report: [KernelFunction(nameof(GetExpenseReport))] [Description("Gets the expense report for an employee on the specified report date.")] public JsonDocument? GetExpenseReport(string employeeName) { var path = Path.Combine(AppContext.BaseDirectory, "Data", $"{employeeName}.json"); if (!File.Exists(path)) { return null; } var jsonContent = File.ReadAllText(path); var report = JsonDocument.Parse(jsonContent); return report; } [KernelFunction(nameof(GetExpensePolicyAsync))] [Description("Gets the travel expense policy for the organization.")] public async Task<string> GetExpensePolicyAsync() { var fullPath = Path.Combine(AppContext.BaseDirectory, PolicyPath); var policy = await File.ReadAllTextAsync(fullPath); return policy.Trim(); } And here's the function to load the policy: [KernelFunction(nameof(GetExpensePolicyAsync))] [Description("Gets the travel expense policy for the organization.")] public async Task GetExpensePolicyAsync() { var fullPath = Path.Combine(AppContext.BaseDirectory, PolicyPath); var policy = await File.ReadAllTextAsync(fullPath); return policy.Trim(); } In a production environment, these could connect to a database, SharePoint site, or cloud storage. Creating and Configuring the Agent Now we create a ChatCompletionAgent, wiring in the tools and specifying how it should interpret the data. This includes system instructions and the output format. var kernel = Kernel.CreateBuilder() .AddAzureOpenAIChatCompletion(deploymentName, endpoint, apiKey) .Build(); kernel.Plugins.AddFromType<ExpenseReportTools>(nameof(ExpenseReportTools)); _chatCompletionAgent = new ChatCompletionAgent { Name = "Expense-Agent", Description = "Agent for expense report processing.", Instructions = $""" You are a expense report processing agent. Apply the organization's expense policy to recommend if expense reports should be approved, denied, or referred to a manager. 'Approve' means the total amount matches the receipts and is within policy limits and rules. 'Deny' means the total amount does not match the receipts, exceeds policy limits, or violates rules. 'Refer' means the expense report requires further review by a manager. Return json with the schema: {JsonSerializerOptions.Default.GetJsonSchemaAsNode(typeof(ExpenseReportRecommendation))} """, Kernel = kernel, Arguments = new KernelArguments( new OpenAIPromptExecutionSettings { FunctionChoiceBehavior = FunctionChoiceBehavior.Required() }) }; We also define a method to invoke the agent and parse the result: public async Task<ExpenseReportRecommendation?> ProcessExpenseReportAsync(string employeeName) { var chatMessage = new ChatMessageContent(AuthorRole.User, $"Process the expense report: {employeeName}."); await foreach (ChatMessageContent chatMessageContent in _chatCompletionAgent.InvokeAsync(chatMessage)) { var response = chatMessageContent.Content ?? string.Empty; if (!response.StartsWith("{")) { continue; } var expensesReportDecision = JsonSerializer.Deserialize<ExpenseReportRecommendation>(response); return expensesReportDecision; } throw new InvalidOperationException("Failed to process expense report"); } This method sends a request to the agent and parses the returned JSON into our predefined class. Putting It All Together Let's try it out by evaluating reports for two employees: var expenseAgent = new Agent(deploymentName, endpoint, apiKey); var employees = new[] { "Alex", "Sam" }; foreach (var employee in employees) { var recommendation = await expenseAgent.ProcessExpenseReportAsync(employee); ArgumentNullException.ThrowIfNull(recommendation, nameof(ExpenseReportRecommendation)); Console.WriteLine($"Recommendation for {employee}:"); Console.WriteLine($"Employee Name: {recommendation.EmployeeName}"); Console.WriteLine($"Report Date: {recommendation.ReportDate.ToShortDateString()}"); Console.WriteLine($"Amount Reported: {recommendation.AmountReported:C}"); Console.WriteLine($"Receipts Total: {recommendation.ReceiptsTotal:C}"); Console.WriteLine($"Recommendation: {recommendation.Recommendation}"); Console.WriteLine($"Summary: {recommendation.Summary}"); Console.WriteLine("-------------------------------------------------------"); } Console.WriteLine("Press any key to continue..."); Console.ReadKey(); In this example:
  • The agent recommends approving Alex's report.
  • Sam's report is denied due to a discrepancy between the total reported and the attached receipts.
Try modifying the policy to allow small discrepancies or relax other rules - and see how the agent adapts its reasoning accordingly. Why This Matters This isn't just automation - it's decision automation. The agent:
  • Reads semi-structured or natural language inputs
  • Interprets human policies
  • Produces explainable, auditable decisions
It shows how large language models can act as reasoning engines for enterprise workflows, delivering decisions that are both scalable and accurate - all within your .NET environment.
Read More
Create Clarity
Blogs
.NET

RAG with SQL Server in .NET – Build Semantic Search with Azure AI

Learn how to build a RAG pipeline in .NET using SQL Server 2025 vector search, Azure AI Vision, and Azure AI Foundry to power intelligent semantic photo search.
Read More

Filters

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