At FPT Software's AI Center, we recognize AI's unique potential in software development and developed CodeVista, our own tool tailored to our specific use cases. Unlike more generalized AI-assisted developer tools like GitHub Copilot and Sourcegraph Cody, CodeVista is specifically designed to meet FPT Software's unique requirements and workflow.

However, how does coding help from an AI assistant differ from a human assistant? Does it improve developer productivity? In this blog post, our team at FPT Software AI Center shares our insights from conducting a controlled experiment to answer these questions. We developed and deployed CodeVista, an AI coding assistant integrated into Visual Studio Code and IntelliJ that answers coding questions and provides context-aware help with coding tasks through pre-built actions or user prompting.

Why This Experiment?​

We set out to collect quantifiable measures of how solving coding problems with CodeVista compares with using help from a human, as well as qualitative user feedback on their experience working with AI. We consider this experiment as a direct and immediate first step to a bigger project – understanding how AI impacts developer productivity and how to steer this impact in a positive direction.

Productivity — An elusive concept​

When discussing developer productivity, we're referring to a range of factors that collectively determine how effectively and efficiently an individual or a team of developers can complete their tasks. This concept is multifaceted and can be influenced by various elements, including but not limited to:

1. Coding Efficiency: Speed and accuracy in writing and refining code.
2. Quality of Code: Clean, maintainable, and bug-free code with good documentation.
3. Problem-Solving Skills: Efficient understanding, designing, and coding of solutions.
4. Learning and Adaptability: Quick adaptation to new technologies and changing requirements.
5. Collaboration and Communication: Effective teamwork and clear idea articulation.
6. Tool Proficiency: Skillful use of development tools to automate and streamline tasks.
7. Time Management and Focus: Effective task prioritization and maintaining concentration.
8. Mental and Physical Health: Well-being's impact on efficiency and work quality.
9. Environmental Factors: Influence of work setting on focus and efficiency.

At FPT Software, our perspective on developer productivity is shaped by our core business model – software outsourcing. Unlike companies that primarily focus on software development for direct sales, like GitHub, our emphasis is on delivering high-quality software solutions with minimal maintenance costs to our clients. In this context, our approach to measuring and enhancing productivity needs to be distinct and customized to our unique business environment.

We believe in starting with a direct and immediate approach to measure productivity. By conducting experiments and surveys in a controlled setting, we can swiftly gather data and insights specific to our developers' working styles and the challenges they face in outsourcing projects.

Experiment Details​

We carried out a controlled experiment to determine the productivity impact of using CodeVista for programming tasks. We recruited 40 developers from our organization with diverse backgrounds, including job titles, levels of work experience, and genders. Participants in this user study will complete a pre-survey, an hour-long programming experiment, and a post-survey to collect user experience data.

The core of the experiment involves eight programming challenges, each requiring knowledge in a specific area of software engineering such as front-end, back-end, algorithms, and engineering skills. For each challenge, we provided two tasks of equal difficulty.

Here's how we structured the tasks:

1. Use only CodeVista when solving one task, without access to an Internet browser or human help.
2. Use only human-provided instructions when solving the other task, without access to an Internet browser or CodeVista. The human instructions are written by senior engineers as if they were mentoring apprentice-level programmers.

This setup allowed each participant to experience both methods – getting help from CodeVista and from human mentors – for tasks of similar complexity. Our research team built a custom platform to provision these coding challenges and collect the code submissions from participants in a controlled manner. This allowed us to track and compare the time taken and the code quality from solving problems with AI versus human instructions.

Key findings:​

• Existing familiarity with AI Developer Tools: 45% of participants already use AI tools like ChatGPT, GitHub Copilot, TabNine, and others to help with their work.
• Overall Productivity Increase with CodeVista: By using CodeVista, our group of participants gains 48% in the number of accurately solved tasks while saving 48% of the time compared to using human instructions.
• Productivity Gains Across Skill Levels:
  • Group A (Proficient Developers): Completed an equal and sometimes higher number of tasks with CodeVista, but with significant gains in speed.
  • Group B (Less Proficient Developers): Completed a consistently much higher number of tasks showing its utility across different skill levels.
• Seeing is Believing: After experiencing first-hand how positively AI assistance compares to human instructions, over 90% of participants report having their expectations exceeded by CodeVista.

For more information on each finding, please see the sections below.

Finding 1: 45% of participants already use AI tools in their daily routines.

Our developers use AI to support their daily work routines. According to the surveys we conducted, popular tools include ChatGPT, GithubCopilot, DocifyAI, Tabnine, and others. When they use AI coding assistants as part of their development workflow, they hope that it will help speed up, suggest, review, and optimize code, thereby assisting them with their development tasks.

Finding 2: CodeVista can increase productivity by approximately 48% and save resolution time by 48%.

Under the same task-difficulty conditions, CodeVista shows remarkable efficacy in assisting participants to complete more tasks. On average, with CodeVista's assistance, each participant can solve 7.25 tasks, whereas they can only provide accurate answers for 4.9 tasks using step-by-step instructions. This results in a 48% increase in productivity when compared to following instructions for problem-solving. Furthermore, these tasks are completed faster, saving programmers 48% of their time. This highlights the significant time and productivity gains that can be achieved by integrating CodeVista into the software development process.

Finding 3: CodeVista can be helpful for all developers.

Group A — Proficient developers Group B — Less proficient developers

Observing the data, we notice two emerging groups of participants:​

• Group A: 20 participants completed six or more tasks following instructions, indicating a proficient level of programming skills.
• Group B: 20 participants completed fewer than six tasks using only instructions, suggesting a lower level of programming proficiency than Group A.

Within each group, we see a wide range of job titles, years of professional experience, and coding frequency. It demonstrates that this categorization has little effect on performance in our experiment.

• Instead of following detailed instructions, all participants completed the same number of tasks or more using CodeVista.
• In group A, even with proficient programming skills, participants can save time by solving problems using CodeVista instead of relying only on instructions.
• In group B, some users spent all of their time-solving problems with CodeVista, indicating an affinity for solving problems with AI assistance.

Finding 4: CodeVista exceeded 90% of participants' expectations.

Following the conclusion of our user study campaign, the remarkable performance of CodeVista became abundantly clear as it surpassed the expectations of over 90% of the participants. This notable achievement underscores the effectiveness and positive impact of CodeVista. The willingness of participants to add CodeVista as their favorite extension speaks volumes about its ability to enhance the coding experience, solidifying its status as a tool for optimizing productivity and efficiency in the dynamic field of software development.

Conclusion on CodeVista's Impact: Insights and Future Directions​

As we conclude our controlled experiment on CodeVista, it's crucial to consider what these findings mean for developers, especially in the context of a software outsourcing company like ours. Our goal at FPT Software is not just about enhancing efficiency; it's also about enriching the work experience of our developers and, in turn, delivering superior service to our clients.

The findings from our study with CodeVista resonate with the broader industry's exploration of AI in software development. Similar to GitHub Copilot's impact, we're witnessing a growing interest in how AI tools can transform traditional coding practices.

Looking Ahead​

The field of AI-assisted programming is rapidly evolving, and our research is just the beginning. We're excited to continue exploring how tools like CodeVista can be integrated more deeply into our workflows, and we're eager to contribute to the broader discussion on AI's role in software development.

As we move forward, we plan to expand our research to include more comprehensive methods, like long-term case studies and in-depth analysis of in-app metrics. These efforts will help us better understand the full spectrum of benefits that AI can bring to software development, especially in an outsourcing context.

In conclusion, the journey with CodeVista has been enlightening, and we are optimistic about the future of AI in software development. We look forward to sharing more insights and breakthroughs as we continue to innovate and learn in this exciting field.

When Outdated Documentation Breaks Everything​

Imagine you are part of a fast-growing product team in a mid-sized tech company. You're a full-stack developer contributing to a codebase that is deployed to production multiple times a week. The product is evolving rapidly, the team is expanding, and different services are being updated in parallel by backend, frontend, and mobile developers.

Everything is moving fast — and that's when documentation becomes a silent bottleneck.

One morning, a QC engineer reports a failure in the frontend UI: the user profiles aren't loading correctly. As the frontend developer assigned to the ticket, you begin tracing the issue. You check the API documentation: the endpoint still lists the username field as required.

You build your request accordingly. But it fails.

After hours of debugging, you discover the issue wasn't in your code at all — a backend engineer had renamed username to user_id in the API response two days ago. The documentation was never updated. There was no announcement, no pull request note — and no way for you to know.

The result? Several hours lost, multiple team members pulled into unnecessary troubleshooting, and growing frustration between teams.

Everyone Agrees Documentation Is Important — So Why Is It Always Missing?​

If you ask any developer whether documentation is important, you'll get the same answer almost every time: yes, absolutely.

We all know it helps teams collaborate, smooths out onboarding, makes debugging faster, and keeps the codebase maintainable. It's not up for debate.

But here's the disconnect: Everyone agrees it's necessary — yet almost no one has time to actually write it.

In high-velocity development environments, manual documentation consistently falls behind. It relies on someone remembering — or having the time — to update descriptions, parameters, and data structures. As soon as the pace of delivery increases, documentation starts to drift away from the code, becoming misleading or completely obsolete.

This is not a sign of negligence. It's a byproduct of moving fast without the proper tooling.

A Modern Problem Demands a Modern Solution​

The software industry is well aware that manual documentation can't keep up with the speed of modern development. To address this, many teams have turned to automation — building tools that reduce the manual effort and keep documentation closer to the code. Thanks to advancements in both open-source ecosystems and commercial developer tools, auto documentation has become widely accessible and easy to adopt.

However, traditional solutions often rely on structured input or manual annotations, limiting their effectiveness. This is where AI offers a significant advancement. Tools like GitHub Copilot, Sourcery, and CodiumAI help generate inline comments, docstrings, and even code explanations based on function behavior. These technologies mark a clear shift toward more intelligent documentation workflows. However, many existing solutions still depend on structured input, predefined templates, or manual prompts. This limits their flexibility and often requires extra setup — especially in larger, fast-changing codebases.

CodeVista addresses this challenge with Autodoc: a context-aware system that understands your codebase and generates clear, natural-language documentation automatically — no annotations required.

Meet CodeVista Autodoc Feature​

AI-powered development support — including effortless documentation.

Autodoc leverages advanced code analysis to interpret functions, methods, and classes, then suggests relevant documentation in natural language. Developers can initiate this feature directly within the code editor with minimal effort:

• Step 1: Select the desired code snippet for which you would like to generate documentation. (This step is optional — if skipped, Autodoc will process the entire file.)
• Step 2: Right-click on the coding file.
• Step 3: Navigate to CodeVista > Generate Comments.

Once triggered, CodeVista will analyze the selected code and begin generating docstrings or inline comments accordingly.

The tool will then generate appropriate docstrings and comments tailored to the selected code context. In Visual Studio Code, Developers can gain access to a structured Refactor Preview interface for reviewing and applying changes:

• Step 4: To view preview generated comments in detail, Developers select to view in side-to-side interface.

• Step 5: Finally, Developers select to confirm apply or discard generated documentation.
  • Click Apply to confirm and insert the selected documentation into your codebase.
  • Click Discard to cancel all proposed changes.

This review flow ensures transparency, allowing teams to adopt automated documentation with full editorial control.

With CodeVista Autodoc, documentation becomes a built-in part of the development workflow — consistent, accurate, and always up to date.

Imagine you're a Business Analyst at a logistics tech company. While reviewing call center reports and attending a stakeholder workshop, you spot a pattern: customers frequently call to reschedule deliveries, creating frustration for both clients and agents.

Recognizing this as a gap in the customer journey, you take the initiative to propose a rescheduling feature for the customer portal. But when you hand your idea to the development team, things don't go as planned. Developers misinterpret the user flow, key UI details are unclear, and backend integration questions arise. The result is delays and rework, turning a simple enhancement into a drawn-out project. You realize that, despite your clear vision, your communication left too much room for misunderstanding.

Turning Ideas into Reality: The Challenges​

Even the most well-defined ideas can fall apart during execution if they aren't visualized or grounded in real context. Traditional documentation, no matter how thorough, often leaves room for interpretation when it comes to user interactions, system behaviors, or integration flows. Without something tangible to see or test, teams risk building the wrong thing, or worse, wasting time clarifying assumptions.

For Business Analysts, this challenge is especially critical. Their role is to translate business needs into actionable requirements, but when those requirements remain abstract, their value gets lost in translation. A well-written user story or process diagram may still fail to convey the full user experience or edge-case logic that the team need to implement confidently.

While tools like Figma or Balsamiq help visualize ideas, they often require design skills and significant time, even for simple flows. For Business Analysts, who need to move quickly between stakeholder discussions and requirement validation, these tools can slow down iteration. Building and linking screens, simulating logic, and polishing layouts takes time that many BAs don't have, leading them to fall back on static documents that lack clarity.

Generative AI — The Key to Rapid Prototyping​

Many Business Analysts are now asking: Can today's powerful AI help with prototyping? The answer is increasingly yes. With advanced AI-powered tools, you can simply describe a feature in natural language, and an AI agent instantly creates interactive mockups. This doesn't replace design teams, but empowers BAs to validate ideas quickly, align stakeholders early, and provide clearer requirements to development.

Previously, prototyping required design expertise and lots of time, causing delays. Now, AI agents can turn descriptions like "A user reschedules a delivery" into clickable prototypes in minutes — no design skills needed. Stakeholders and developers can interact with these models, minimizing misunderstandings. In today's fast-paced environment, AI-driven prototyping is quickly becoming essential for Business Analysts to turn ideas into real impact, faster than ever before.

Meet Prototyper: Revolutionizing Prototyping with Generative AI​

In the world of software development, speed is often the key to innovation. Whether you're an engineer, product manager, or startup founder, the ability to translate an idea into a working prototype quickly can define your success. Enter Prototyper, an AI Agent built into CodeVista, designed to radically accelerate the prototyping process through the power of Generative AI.

What Prototyper Can Do​

Prototyper isn't just a chatbot that writes code snippets but also behaves like a smart technical assistant that can:

• Generate files and scaffold entire projects
• Run shell commands to install dependencies or initialize environments
• Organize task flows for app bootstrapping
• Maintain a recent tasks history, so users can revisit what they've built

This makes it ideal not only for engineers but also for business analysts, product designers, or anyone looking to explore ideas through functional mockups.

How Prototyper Works​

1. Launch Prototyper from the Agent Store in CodeVista.
2. Type a natural language prompt, such as: Create a interface for Leave Request Management.
3. Watch as Prototyper generates the required files, directory structure, and even terminal commands automatically.

No clicking through templates. No copy-pasting from documentation. Just your idea, translated into code.

When to Use Prototyper​

Prototyper is most powerful when:

• You need to quickly test or demo an idea
• You're starting a new project and want a jumpstart
• You want to reduce the setup time for common development tasks
• You're validating multiple design options or workflows in rapid succession

It's also a great tool for workshops, hackathons, or MVP development, where time-to-delivery is critical.

Ready to Build Smarter and Faster? Try CodeVista​

Prototyper is just one of many intelligent agents in the CodeVista ecosystem: each designed to simplify the software development lifecycle. Whether you're prototyping, coding, testing, or documenting, CodeVista brings AI directly into your workflow.

Start exploring CodeVista today and experience a smarter, faster way to build.

To learn more about CodeVista Prototyper, please refer to the Prototyper User Guide on our website.

Strengths and Weaknesses of Leading AI Models in 2025​

AI models have become increasingly powerful, each excelling in different areas. Below, we analyze the strengths and weaknesses of five prominent AI models and suggest the best use cases for each.

Final Thoughts​

Each of these models shines in different domains. If you need top-tier reasoning and coding, Claude 3.7 Sonnet or GPT-4o are excellent choices. For speed and efficiency, Gemini 2.0 Flash and GPT-4o Mini perform well. Choosing the right AI depends on your specific needs, whether it's coding, content creation, or real-time chatbot interactions.

Navigating the Complexities of Large-Scale Code Repositories​

Developers across all levels and domains inevitably encounter the complexities of large repositories, each facing unique yet interconnected challenges. As repositories grow in size and complexity, developers at every level must adopt strategies like sparse checkouts, incremental builds, and distributed CI/CD architectures to maintain efficiency and prevent workflow bottlenecks.

Recognizing the challenges developers face, CodeVista introduces the Repo Navigator feature to streamline repository exploration and code comprehension. Based on the context of the question, CodeVista intelligently identifies and retrieves relevant files and symbols, incorporating them into responses as linked references and code snippets.

By leveraging @workspace as a grounding mechanism, CodeVista Chat transforms into a domain-specific assistant, optimized for tasks including but not limited to:

• Finding existing code in your codebase
• Querying logic and execution flow
• Making plans for complex code edits
• Explaining higher-level concepts in a codebase

How Repo Navigator works?​

Repo Navigator provides a graph-based representation and retrieval system for codebases, enabling seamless integration with Large Language Models (LLMs) and AI-powered coding assistants. By leveraging RAG-Graph (Retrieval-Augmented Generation Graph), it enhances LLM capabilities and helps developers tackle complex tasks efficiently.

Its functionality consists of three key processes:

1. Building a Graph: Indexing source code into a structured, searchable graph, capturing relationships between classes, methods, variables, and files using advanced parsing techniques.
2. Orchestrating Jobs to Enhance Code Understanding: Running workflows to improve code understanding through dependency resolution, refactoring suggestions, and structural insights, integrating with RAG-Graph for context-aware operations.
3. Querying Codebase: Supports advanced queries to retrieve code snippets, dependencies, and references, assisting with debugging, feature development, and optimization.

How to use Repo Navigator?​

Step 1: Upload code files that are currently open in your workspace to the CodeVista context system.​

(Supported coding file types: C, C++, Java, JavaScript, PHP, Python, Ruby, Go, Rust, TypeScript, Kotlin)

Once the Workspace Q&A Status is Ready, your workspace has been fully indexed and CodeVista now has a complete understanding of its content. The system is now prepared to answer questions accurately based on the indexed data and provide insights, cross-references, or direct responses to queries about the workspace.

Step 2: Input @workspace questions and submit to CodeVista.​

See Tips for Using Repo Navigator for more ideas to optimize responses from CodeVista.

Step 3: Review response from CodeVista and ask for more information if needed.​

All @workspace Q&A are saved and can be reopened in Task Status for review.

Tips for effective use of Repo Navigator​

The way you phrase your question can significantly influence the quality of the references @workspace provides and the accuracy of the response. To optimize results, consider the following tips:

• Be specific and detailed in your question, avoiding vague or ambiguous terms like "what does this do" (where "this" could be interpreted as the last answer, current file, or whole project, etc.).
• Incorporate terms and concepts in your prompt that are likely to appear in your code or its documentation.
• Review the code symbols reference in the response to ensure that the files are relevant. Iterate on your question if necessary.
• Responses can draw from multiple references, such as "find exceptions without a catch block" or "provide examples of how handleError is called". However, don't anticipate a comprehensive code analysis across your codebase, such as "how many times is this function invoked?" or "rectify all bugs in this project".
• Avoid assuming information beyond the code (for now), such as "who contributed to this file?" or "summarize review comments for this folder".

Related Resources​

• Code Context
• Workspace Q&A

The world of Artificial Intelligence is experiencing a profound transformation, driven by the emergence of AI Agents. These aren't just sophisticated algorithms; they're autonomous entities capable of perceiving, thinking, and acting.

What Are AI Agents?​

At their core, AI Agents are intelligent systems designed to interact with their environment. They operate by sensing information (e.g., through cameras, microphones, or text analysis), thinking (processing that data using AI capabilities like machine learning and logical reasoning to make decisions), and then acting to achieve specific goals (executing physical or digital tasks). This ability to autonomously perceive, process, and act enables AI Agents to navigate and influence the world in unprecedented ways.

The Power of AI Agents: Benefits and Trends​

The widespread adoption of AI Agents is fueled by their significant advantages:

• Elevated Automation: Agents excel at automating complex and repetitive tasks, boosting efficiency and reducing errors.
• Adaptive Intelligence: Many modern agents learn and adapt, continuously improving their performance based on experience.
• Intelligent Decision-Making: They can quickly analyze vast datasets to make optimized decisions, often surpassing human capabilities in speed and precision.

Key trends in Agent development point towards more sophisticated capabilities: Multi-Agent Systems where agents collaborate, the push for Truly Autonomous Agents that require minimal human intervention, and the growing field of Human-Agent Collaboration that focuses on augmenting human abilities. Crucially, Large Language Models (LLMs) are revolutionizing agents, providing them with advanced reasoning, planning, and natural language interaction capabilities, often leveraging external tools.

CodeVista Planner Agent: Orchestrating Development from Idea to Implementation​

Among these promising advancements, a compelling and practical application emerges in the form of the Planner Agent. This is where AI moves beyond simple execution to intelligently craft a step-by-step roadmap for complex goals. A prime example embodying this innovation is CodeVista's Planner Agent.

The Planner Agent is an intelligent AI agent designed to help you plan and complete development tasks step by step. It makes task automation smarter and more efficient, allowing developers to focus on ideas and problem-solving while the agent handles the intricate planning and execution. This makes development faster, smarter, and more structured.

Here's how you can leverage its power:

1. Enter Your Prompt​

In the chat input, simply type the development task you want the Planner Agent to perform.

For example: "Please create sorting function in python language." Hit Enter to send it off.

2. View the Plan​

The Planner Agent automatically breaks down your request into a series of actionable steps.

You'll see a clear, structured plan, guiding you from your initial idea to full implementation.

3. Execute Commands & Review​

Within the plan, you'll find code blocks and commands.

Click the "Run" button to execute the script for a specific step.

After running, you'll instantly see the program's output.

AI Agents are not just a futuristic concept; they are actively shaping the present, driving unprecedented levels of automation and efficiency. CodeVista's Planner Agent stands as a vivid testament to this immense potential within the software development lifecycle. It's more than just a time-saving tool; it's an intelligent partner designed to empower developers to bring their ideas to fruition quickly, structurally, and more effectively than ever before.

Are you ready for CodeVista's Planner Agent to turn your ideas into reality? Give it a prompt and see for yourself!

To learn more about CodeVista Planner Agent, please refer to the Planner Agent User Guide on our website.

Note: The Planner Agent is currently only supported in CodeVista for IntelliJ.