The Problem

At Kindred, we relied on Remote Desktop Manager (RDM) to manage connections to our Windows and Linux hosts for broadcasting commands and checking system states. However, licensing costs were high and every new host required manual database entry. After finding no suitable alternatives, I decided to build my own solution.

Solution Design

SSHplex needed three core capabilities: a modern terminal UI with host selection and bulk operations, flexible data source integration (NetBox and Ansible inventory), and terminal multiplexer support with session persistence for background tasks.

Development Approach

Following KISS principles, I structured development in three phases. First, building the foundation with configuration, NetBox connectivity, basic TUI, and single SSH connections. Second, adding multi-select functionality, tmux session management, and error handling. Finally, implementing command broadcasting, session persistence, and performance optimization.

The modular architecture allowed rapid iteration while maintaining clean separation between UI, data sources, and multiplexer logic. I implemented CI/CD early with two pipelines: PR-triggered testing and linting, plus tag-based releases to GitHub and PyPI with automated changelog generation.

Implementation Strategy

I leveraged modern development practices with comprehensive testing using pytest, automated quality checks with flake8 and mypy, and semantic versioning. The pipeline caught integration issues early and reduced manual overhead significantly.

Leveraging Large Language Models

My experience highlighted the importance of choosing the right AI tool. Initially using Claude Sonnet 3.5, I encountered over-engineering and inconsistent results. Switching to Claude Sonnet 4 in VS Code transformed the experience with precise execution and better context understanding.

Rather than random suggestions, I used structured prompts like: “Create a NetBox API client class with connection pooling, automatic retry logic with exponential backoff, proper SSL certificate handling, and comprehensive error handling for device and VM queries.”

The LLM excelled at boilerplate elimination, API integration patterns, test coverage generation, and maintaining consistent code patterns. I treated it as a sophisticated pair programmer where architecture decisions remained human-driven while leveraging AI efficiency for implementation details.

This collaboration increased development velocity by approximately 40% while maintaining code quality. The key was keeping human judgment central to design decisions while using AI as an advanced autocomplete tool for consistent implementation patterns.

The result is a robust tool that addresses real infrastructure management challenges through methodical development and strategic AI assistance.

For more detailed technical information about the development process, AI collaboration strategies, and implementation specifics, see the complete article.

The Problem

At Kindred, we relied on Remote Desktop Manager (RDM) to manage connections to our Windows and Linux hosts. I primarily used it to connect to multiple VMs simultaneously and broadcast commands to check system states or run quick commands where Ansible ad-hoc was either too slow or when I needed immediate feedback.

However, we faced two major issues:

• Licensing costs: The license was expiring and renewal was expensive
• Maintenance overhead: Every new host had to be manually added to the RDM SQL Server database

After searching for alternatives, I found nothing that met our specific needs. So I decided to build my own solution.

Solution Design

I identified three core requirements for the new tool:

🖥️ Modern Terminal User Interface

• Host selection interface with search capabilities
• Bulk selection with hotkeys (like pressing ‘A’ to select all)
• Command broadcasting across multiple SSH sessions

🔗 Flexible Source of Truth Integration

• NetBox integration for VMs and devices
• Ansible inventory support with merging capabilities from multiple files
• Extensible architecture for future data sources

🖼️ Terminal Multiplexer Support

• tmux integration as the initial multiplexer (widely available with excellent Python libraries)
• Extensible design for future multiplexer support
• Session Keepalived sometimes i close my terminal but i want my background task to work and comming back to it

Development Approach

I followed the KISS (Keep It Simple, Stupid) principle and broke development into three phases:

Phase 1: Foundation

1. Configuration system with proper validation
2. NetBox connectivity and VM listing
3. Basic TUI for host selection
4. Single SSH connection functionality
5. Logging infrastructure with proper namespacing

Phase 2: Core Features

1. Multi-select capability in the TUI
2. tmux session management with multiple panes
3. Connection error handling and retry logic
4. Search and filtering functionality

Phase 3: Polish & Performance

1. Command broadcasting between panes
2. Session persistence and management
3. Advanced error recovery mechanisms
4. Performance optimization with intelligent caching

CI/CD

After having a first version i quickly needed a pipeline to test/lint my code and deploy it easily into github and pypi I created 2 pipeline:

1. The first one was a ci based on PR trigger, to check for linting and basic test (demo mode in my app)
2. The seccond one was for building and releasing the app based on tags, it uploads to github releases with a description based on commits and also release it to pypi for pip install

Implementation Strategy

I leveraged GitHub Copilot extensively during development, using structured prompts to maintain consistency and follow best practices. The modular approach allowed me to:

• Iterate quickly on each component
• Test incrementally as features were added
• Maintain clean separation between UI, data sources, and multiplexer logic
• Plan for extensibility from the start

This methodical approach ensured that SSHplex evolved from a simple concept into a robust tool that addresses real infrastructure management challenges.

CI/CD Pipeline

Building a reliable CI/CD pipeline was crucial for maintaining code quality and enabling rapid iteration:

🔄 Automated Testing & Quality

• GitHub Actions for continuous integration
• Pytest with comprehensive test coverage for core functionality
• Code quality checks using flake8 and mypi for consistent formatting

📦 Package Distribution

• PyPI publishing with automated versioning and release notes
• Multi-version testing across python versions

🚀 Release Strategy

• Semantic versioning with automated changelog generation

The pipeline reduced manual overhead significantly and caught integration issues early, allowing me to focus on feature development rather than release management.

Leveraging Large Language Models

My experience with LLMs during this project highlighted the importance of choosing the right tool for the task:

🔄 Evolution of AI Assistance

Initially, I started with Claude Sonnet 3.5, but encountered several limitations:

• Over-engineering: Often generated unnecessarily complex solutions
• Context misunderstanding: Frequently missed the specific requirements or intent
• Inconsistent results: Code quality varied significantly between iterations

When Anthropic announced Claude Sonnet 4 in preview (available in VS Code), the experience transformed completely:

• Precise execution: With clear instructions, it consistently delivered working Python code
• Agent mode debugging: Exceptional at identifying and fixing issues autonomously
• Intent understanding: Better grasp of project context and requirements

🎯 Strategic Implementation Approach

Rather than relying on random code suggestions, I developed a structured workflow:

Detailed Instruction Sets:

"Create a NetBox API client class with connection pooling, automatic retry logic
with exponential backoff, proper SSL certificate handling, and comprehensive
error handling for device and VM queries. Include logging and timeout management."

Iterative Refinement:

• Start with high-level architecture prompts
• Break down complex features into smaller, specific tasks
• Use the agent mode for debugging and optimization passes

💡 Key Success Areas

The LLM excelled particularly in:

• Boilerplate elimination - Configuration parsing and validation schemas
• API integration patterns - Consistent error handling across different data sources
• Test coverage generation - Comprehensive unit test scaffolding
• Code refactoring - Maintaining consistency across modules during iterations

⚖️ Human-AI Collaboration Balance

The most effective approach was treating the LLM as a highly skilled pair programmer:

• Architecture decisions remained human-driven
• Implementation details leveraged AI efficiency
• Domain expertise guided prompt engineering and validation
• Code review ensured real-world applicability

This collaboration model increased development velocity by approximately 40% while maintaining code quality and architectural integrity.

💡 Code Generation & Boilerplate

• Configuration parsing - Copilot excelled at generating YAML validation schemas
• API integration code - Particularly helpful for NetBox API client implementation
• Error handling patterns - Consistent exception handling across modules
• Test case generation - Automated creation of unit test scaffolding

🎯 Structured Prompting Strategy

Instead of random suggestions, I used specific prompts:

"Generate a NetBox API client class with connection pooling,
retry logic, and proper error handling for device queries"

"Create a tmux session manager that handles pane creation,
layout management, and graceful cleanup on session termination"

⚖️ Human Oversight & Validation

• Code review - All generated code underwent manual review
• Architecture decisions - LLM suggestions informed but didn’t dictate design choices
• Domain expertise - Combined AI efficiency with infrastructure knowledge
• Testing validation - Ensured generated code met real-world requirements

📈 Productivity Impact

Using LLMs strategically increased development velocity by approximately 30-40%, particularly in:

• Reducing boilerplate writing time
• Accelerating API integration development
• Generating comprehensive test coverage
• Maintaining consistent code patterns

The key was treating Copilot as a sophisticated autocomplete rather than an architect - keeping human judgment central to design decisions while leveraging AI for implementation efficiency.

Overview

For years, there was a significant gap in available tools: the only existing Centreon Terraform provider was built around the legacy CLAPI, which had not been updated in over five years. While there was also a V1 (distinct from CLAPI), it lacked the features needed for modern infrastructure management. My need for an up-to-date solution at Kindred pushed me to create a new provider based on the latest Centreon API V2, ensuring future-proof functionality and seamless integration with current workflows.

AI-Powered Development Workflow

The AI-driven process was central to my success. Here’s how I leveraged it:

• Using OpenAPI Documentation as Context: I provided the Centreon API documentation to the AI, which generated integration code complete with logging, unit tests, and robust error handling.
• GitHub Copilot & Insider Agent Mode: Enhanced by the latest insider agent mode and the Claude Sonnet 3.5 model, GitHub Copilot in VSCode helped me interactively ask questions about code segments. This allowed me to understand the generated code, manage follow-up queries effectively, and reframe prompts when needed.
• Iterative Testing: I continuously asked the AI for explanations and tested the code, refining it until it met the necessary standards. This “managing the AI as a worker” approach was a game changer, providing clarity and a much-needed boost in confidence.

Tools and Technologies

This project integrated a variety of tools to create a solid foundation for developing the provider:

• GitHub & GitHub Actions: Handled source control, CI/CD workflows, and automated testing.
• Terraform Provider SDK V2: Served as the framework for building provider-specific functionalities.
• Go: Became my primary language, with AI assistance bridging the gap from my Python background.
• Linters & Makefiles: Ensured code quality and streamlined the build process.
• Unit Tests: Played a critical role in ensuring the reliability and maintainability of the provider.
• Tags and Releases: Automated versioning and release management to maintain a clear project history.
• Documentation & Contributing Workflow: Established guidelines for external contributions and issue management.

I used the Terraform Provider Scaffolding Framework as my base repository for CI/CD, among other practices. However, I intentionally skipped the copyright tool offered by HashiCorp—since it would transfer code ownership to HashiCorp—to keep the project completely open source.

Challenges and Lessons Learned

The journey was not without its challenges:

• Prompt Engineering: Crafting the right prompts was key. At times, follow-up questions led to context drift, requiring me to reset the conversation and guide the AI back on track.
• Managing Context: A larger context improved code coherence but sometimes resulted in an overload of follow-up queries that needed to be pruned.
• Tool Limitations: While GitHub Copilot in VSCode was a powerful assistant, occasional misalignments or unexpected bugs required me to intervene and adjust the AI’s output.

Each challenge became a valuable lesson, improving the quality of the provider and deepening my technical expertise in Go and CI/CD integrations.

Conclusion

Developing a Terraform provider for Centreon API V2 using AI was a practical, hands-on experience that significantly expanded my technical skill set. By combining modern AI tools with best practices and robust testing methodologies, I was able to fill a long-standing gap in the Centreon ecosystem and produce a provider that meets modern standards. This project not only improved my proficiency in Go and open source development but also reinforced the value of AI as an essential tool for system engineers.

Originally published on the HuGO blog.

About Me

I’ve built my career around understanding and implementing robust system architectures, but I believe there’s always room to grow. Recently, I’ve been diving deeper into programming with a particular focus on Go and Python. Despite being what some might call a “late learner” in the programming world, I’m determined to master these skills to complement my systems expertise.

What to Expect

This blog will serve as a chronicle of my experiences and projects. I plan to share:

• Technical tutorials and walkthroughs
• Insights from my professional journey
• Personal projects combining systems engineering and programming
• Lessons learned along the way

I believe in the power of sharing knowledge, and I hope that documenting my journey might help others with similar interests or career paths.

So here we go! The beginning of what I hope will be an insightful collection of posts for both myself and anyone who stumbles upon this corner of the internet.

Stay tuned for more!