According to Stanford’s 2025 AI Index Report, 78% of organizations now use AI in at least one business function, up from just 51% the previous year.
This explosive growth shows how quickly AI has moved from experimental technology to an essential business tool.
From writing emails and creating presentations to analyzing data and generating creative content, AI has become like having a super-smart productivity partner that works around the clock without ever needing a coffee break.
Most AI tools need constant guidance, but autonomous agents like Manus AI are changing that. We tested it on 8 real-world coding tasks, from Python and debugging to web apps and React projects.
These covered everything from generating Python programs and debugging broken functions to explaining algorithms, building responsive web pages, creating mini web apps, and even scaffolding React projects.
What is Manus AI?
Manus AI is an autonomous intelligence agent developed by the Chinese startup Monica and launched in March 2025. Unlike standard chatbots that need constant user input, Manus can independently plan, execute, and complete complex tasks.
It functions like a digital employee, operating in the cloud and continuing work even when the user is offline. Once a task is complete, Manus sends a notification with results rather than requiring step-by-step oversight.
What makes Manus stand out is its integration of advanced models like Claude 3.5 and Qwen. This multi-model approach allows it to achieve higher accuracy and tackle diverse workflows.
How does Manus AI work?
Manus doesn’t just spit out answers; it actually works through tasks like a teammate would. Think of it as a digital colleague that takes your request, figures out the plan, and quietly gets it done while you move on to other things.
Manus AI scorecard
We tested Manus AI on eight real-world coding challenges that covered Python scripting, debugging, algorithm explanation, front-end development, and React scaffolding.
Each task was scored on key performance indicators such as code execution, validation, clarity of explanations, accessibility, and handling of edge cases.
The table below shows the score for every task along with its goal or description, giving a clear snapshot of where Manus AI excelled and where small gaps remain.
| Task name | Description | Score out of 5 |
| Currency Converter (Python) | Build a script to convert USD into EUR, INR, and GBP with input validation, formatting, and sample output. | 5.0 |
| Debugging: find_max (Python) | Fix a broken Python function, explain all bugs, and provide a corrected version that handles empty and negative lists. | 5.0 |
| Bubble Sort Explanation | Explain bubble sort code line by line in simple words with a worked example run for beginners. | 5.0 |
| Real Estate Landing Page (HTML/CSS) | Generate a single HTML+CSS page with hero, property cards, and contact form, ensuring responsiveness and accessibility. | 5.0 |
| Temperature Converter Web App | Build a web app to convert Celsius ↔ Fahrenheit with input validation, formatting, responsiveness, and error handling. | 4.5 |
| Factorial: Python → JavaScript | Translate a Python factorial function into JavaScript with input checks and a clear explanation of syntax differences. | 4.5 |
| React App Scaffold (Data Science Services) | Create a scaffold React app with functional components, placeholders, and setup instructions. | 4.5 |
| Single Player Guess Who Game | Build a browser-based guessing game with 24 characters, yes/no questions, eliminations, final guess, and reset. | 4.0 |
Test Cases for Coding
Task A Currency Converter (Python)
Goal/objective
We tested whether Manus AI could generate a Python script that performs currency conversion from USD to EUR, INR, and GBP using fixed rates, while also validating user input.
The aim was to confirm that the script not only produces correct numerical results but also rejects invalid inputs such as non-numeric, zero, or negative values with clear error messages.
The final requirement was that the program should format results consistently to two decimals and provide a working sample run with 100 USD.
Prompt used
Write a Python program named currency_converter.py. The program should:
– Take user input: amount in USD (float).
– Convert to EUR, INR, and GBP using fixed rates: 1 USD = 0.92 EUR, 1 USD = 83.5 INR, 1 USD = 0.78 GBP.
– Validate input. If input is not a positive number, print a clear error message.
– Print each converted value formatted to 2 decimals and include currency code.
– Show one sample run with input 100.
Return the full Python code and the sample run output.
Output analysis
When we tested the program with 100 as input, it gave the right results: 92.00 EUR, 8350.00 INR, and 78.00 GBP. Each number was rounded to two decimals and clearly marked with the correct currency code, showing that the main feature worked as expected.
We also tried invalid inputs to see how the program reacted, and it handled them well. Typing “abc” showed the message “Invalid input. Please enter a number,” and entering -50 or 0 showed “Invalid input. Please enter a positive number,” proving that it checks both type and value before running.
The program never crashed, even when given bad input. It rejected errors gracefully and gave correct answers whenever valid numbers were entered. The updated version also has simple comments that explain what each part does, which makes it easier to read.
All in all, the script worked exactly as asked. It gave the right results, caught mistakes, showed clear messages, and stayed reliable through every test we tried.
Test scorecard
This task passed all checks: the code runs successfully, handles edge cases, validates input, explains logic with comments, and delivers the correct sample output exactly as specified.
All KPIs were met, so the score is 5/5.
My verdict
The script is complete and reliable. It runs smoothly, is easy to understand, and is now well-documented thanks to added comments. There are no weaknesses left in functionality or validation, so this task can be marked as fully successful.
Task B Debugging: find_max bug (Python)
Goal/objective
We tested whether Manus AI could identify bugs in a broken Python function, explain them clearly, and provide a fixed version that runs correctly. The aim was to confirm that the function no longer throws index errors, avoids the mutable default argument trap, and handles empty lists as well as lists of negative numbers gracefully.
The task also required explanations of the problems and a demonstration of the corrected code working with sample inputs.
Prompt used
Here is a broken Python function. Find every bug, explain the cause in simple words, fix the code, and show correct output for the given calls.
Broken code:
def find_max(nums=[]):
max_val = 0
for i in range(len(nums)+1):
if nums[i] > max_val:
max_val = nums[i]
return max_val
print(find_max([3,7,2,9]))
print(find_max([])) # should return None with message "empty list"Instructions: Provide a fixed version, an explanation of each bug, and sample outputs for both calls.
Output analysis
When we tested the corrected version, it ran without errors and gave the right answer of 9 for the list [3,7,2,9]. When given an empty list, it showed the message “empty list” and returned None, which was the exact behavior required.
We also checked a list with only negative numbers, and it gave the correct maximum rather than an incorrect default value, proving that the fix handled more than just the obvious test cases. The explanation of the fix was simple and clear.
It showed that the old function was crashing because it was looking past the end of the list; it was written in a way that could cause future errors by reusing the same default list, and it started with the wrong assumption that the maximum value was always zero.
The new version avoided these problems by checking for empty input first, picking a real starting value from the list, and then comparing the rest one by one.
Test scorecard
This task passed all checks: the code runs successfully, handles edge cases, validates input, explains its logic clearly, and produces the correct sample output. All KPIs were met, giving it a full 5/5 score.
My verdict
The debugging task was completed thoroughly. Manus AI not only corrected the function but also explained the underlying issues clearly, and the final version now works reliably with regular input, empty lists, and negative values. This task is complete and scored perfectly.
Task C Bubble Sort Explanation
Goal/objective
We tested whether Manus AI could explain an algorithm in a way that is easy for beginners to follow. The focus was not on writing new code but on breaking down the given bubble sort program line by line, using simple language, and showing an example run.
The goal was to see if the explanation would help someone new to programming understand both how the code works and how the data changes step by step.
Prompt used
Explain this bubble sort code step by step so a beginner can follow. Use simple words and add one example run.
Code:
def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
return arrExample input: [64, 34, 25, 12, 22, 11, 90]
Return a line by line explanation, then show the sorted result for the example.
Output analysis
We confirmed that the function itself was not meant to be executed as part of this task, but rather explained. Manus AI gave a full line-by-line breakdown, describing how the function measures the list length, loops over it multiple times, and checks whether two neighbors need to be swapped.
It explained that the biggest unsorted number moves to the end during each pass, which is why the algorithm is called bubble sort. The explanation also included a detailed run-through with the example array [64, 34, 25, 12, 22, 11, 90].
It showed the state of the list after each pass so that the reader could see how the largest unsorted value reached the end step by step. This example run made the process clear even without running the code, and the explanation stayed simple and accessible throughout.
Test scorecard
This task passed all checks: although code execution and edge cases were not applicable, the logic was explained in detail, and the example output was shown clearly. All KPIs that applied were met, so the score is 5/5.
My verdict
The explanation task was completed successfully. Manus AI delivered a clear, beginner-friendly walk-through of the bubble sort algorithm with a thorough example trace, making the logic easy to follow. This fulfills the requirements fully and earns a perfect score.
Task D Real Estate Landing Page (HTML + CSS)
Goal/objective
We tested whether Manus AI could generate a full HTML landing page with embedded CSS that meets design, responsiveness, and accessibility requirements. The aim was to confirm the page included the required sections: hero, six property cards, and a contact form, while ensuring semantic structure, labels, and alt text for accessibility.
The goal was also to check if the design worked responsively without external assets, using only placeholder images.
Prompt used
Create a single-file HTML page for a real estate landing page. Requirements:
– Hero section with title, subtitle, and CTA.
– Grid of 6 property cards. Each card has a placeholder image, title, price, and short description.
– Contact form with name, email, phone, and message.
– Use accessible HTML (labels, alt text).
– Make layout responsive using CSS only.
– Use placeholder images from https://via.placeholder.com/ (no external assets).
Return the full HTML with embedded CSS.
Output analysis
When we opened the generated file in a browser, it rendered correctly with a clean layout. The hero section displayed prominently with title, subtitle, and call-to-action, followed by six property cards arranged in a responsive grid.
Each card included a placeholder image, property details, and a short description, which adjusted well when resizing the browser window, confirming that the CSS was responsive.
The contact form worked visually, with labels for each field and ARIA attributes in place to support accessibility. Images included descriptive alt text, and semantic tags such as header, main, and section were used throughout the structure.
Accessibility enhancements like skip links and focus styles were present, making the page easier to navigate for screen readers and keyboard users. With these checks, the task requirements were fully met.
Test scorecard
This task passed all checks: the HTML and CSS code ran correctly in a browser, the structure was explained, accessibility features were present, and the sample file was delivered as required. All applicable KPIs were satisfied, giving it a score of 5/5.
My verdict
The real estate landing page is complete and functional. It meets every requirement in terms of layout, responsiveness, and accessibility while staying self-contained. The code is clear, works as intended, and is ready to be used or extended further.
Task E Temperature Converter Web App (HTML, CSS, JS)
Goal/objective
We tested whether Manus AI could build a simple web app that takes a temperature value in Celsius or Fahrenheit, converts it to the other unit, and displays the result with proper validation and formatting.
The goal was to confirm that the app performs accurate conversions, rejects invalid inputs with clear messages, and includes basic accessibility and responsiveness in a single self-contained HTML file.
Prompt used
Build a temperature converter web app in one HTML file with embedded CSS and JS. Requirements:
– Input for numeric temperature and dropdown for unit (Celsius or Fahrenheit).
– Convert to the other unit with result shown to 2 decimals.
– Validate input and show friendly error for invalid values.
– Results panel and Reset button.
Return the full HTML file and show sample conversion for 100 C.
Output analysis
When we opened the HTML file in a browser, the app worked smoothly. Entering 100°C and selecting Celsius gave an immediate conversion to 212°F, which confirmed that the core calculation was correct. Invalid entries, such as blank input or text, triggered the error message “Please enter a valid numeric temperature value.”
Values below absolute zero were also rejected with a specific warning, which showed that the logic included thoughtful checks for physical limits. The results panel updated neatly, and the reset button cleared everything as expected.
The HTML was well-structured with labels tied to their fields, semantic tags, and support for decimal inputs. The interface was responsive, and small usability touches like Enter-key submission and auto-focus on load were present.
However, one weakness was that the explanation of the code logic was missing. While the program was easy to follow, the KPI asked for plain-language commentary on the formulas and validation, and this was not delivered.
Because of that, the explanation criterion could not be marked complete, even though every other requirement was met.
Test scorecard
This task met nearly all checks: the code ran correctly, handled edge cases, validated input, provided accessible HTML, and showed the correct sample output. The only gap was the lack of a plain-language explanation of the logic, so the final score is 4.5/5.
My verdict
The temperature converter web app works well and demonstrates good validation, responsiveness, and usability. The only area to improve is providing a short, beginner-friendly explanation of the logic behind the conversion and validation steps. With that addition, the task would reach a perfect score.
Task F Translation: Factorial Python → JavaScript
Goal/objective
We tested whether Manus AI could take a Python function for factorial, convert it into equivalent JavaScript, and explain the key syntax differences in simple terms. The goal was not just to provide working code but also to carry over input validation, handle edge cases like negatives and non-integers, and show an example run that proves the output matches the original Python behavior.
Prompt used
Convert this Python function to clean JavaScript. Keep same behavior and input checks. Explain key syntax differences.
Python code:
def factorial(n):
if not isinstance(n, int) or n < 0:
raise ValueError("Input must be a non-negative integer")
return 1 if n in [0,1] else n * factorial(n-1)Return: JavaScript function, one example call (e.g., 5), and a short explanation in simple words.
Output analysis
The JavaScript function was generated correctly, with checks ensuring the input was a number, was an integer, and was not negative. The recursive structure matched the Python original, and the base cases for 0 and 1 were handled properly.
Input validation worked in theory, with the code throwing an error message when the input was invalid, mirroring the Python version’s behavior. A sample call with 5 produced the expected result of 120.
Where the solution fell short was in execution. The function was written but never actually run in a live environment, such as Node.js. That meant we could not confirm beyond doubt that it would execute without errors.
The explanation file, however, did an excellent job: it broke down differences in type checking, error handling, recursion, and syntax in plain words, which fulfilled the explanatory requirement. Because the code was not tested directly, the CodeRuns KPI could only be scored half a point, but every other KPI was fully satisfied.
Test scorecard
This task met nearly all checks: edge cases were addressed, input validation was implemented, the logic was explained clearly, and a sample output was shown. The only missing piece was actually running the JavaScript code to confirm it worked, so the final score is 4.5/5.
My verdict
The factorial translation was thorough and well-explained, but skipping the execution step kept it from earning a perfect score. The translation itself appears solid, and with a quick verification run, it would have been complete. Overall, the task was successful with a minor gap, earning 4.5/5.
Task G Data Science Services React App Scaffold
Goal/objective
We tested whether Manus AI could generate a React app scaffold for a Data Science Services website. The goal was to confirm that the scaffold included functional components, placeholder data, and clear instructions for setup and use.
Prompt used
Create a small React app scaffold for a Data Science Services website. Include:
– App.js with a Hero, ServicesList, CaseStudyCard, and ContactForm components.
– Each component as a separate functional component.
– Use simple CSS or Tailwind class names.
– Use placeholder images and sample props.
Return the component code files (App.js, ServicesList.js, CaseStudyCard.js, ContactForm.js) and short run instructions.
Output analysis
The project opened and ran without problems. The site loaded in the browser and each section appeared as expected, showing that the structure was correct.
The welcome area displayed the title and short text clearly. The services and past work sections each showed sample information with placeholder images, making the design easy to follow.
The contact form included fields for name, email, and message, and required that they be filled in before submission. While this prevented empty entries, there was no deeper check, such as whether the email was in the right format.
Accessibility was handled well. Each field had a label, every image included alt text, and the overall layout used standard HTML sections that are easier for assistive tools to read.
The instructions for running the site were clear and written in simple steps. A live link was also provided, showing the finished scaffold working in real time.
Test scorecard
This task passed nearly all checks, including CodeRuns, ExplainsLogic, AccessibleHTML, and SampleOutput. Input validation was minimal but present, so the final score is 4.5/5.
My verdict
The React scaffold is complete, reliable, and meets the requirements of the prompt. While more advanced validation could improve it for production, as a scaffold, it is strong and earns 4.5/5.
Task H Single Player Guess Who Game
Goal/objective
We tested whether Manus AI could build a simple browser game similar to “Guess Who” in a single HTML file. The goal was to confirm that the game-generated characters allowed the player to ask yes/no questions, eliminate characters based on answers, and support making a final guess with reset functionality.
Prompt used
Build a single-player Guess Who style game in one HTML file. Requirements:
– Generate a random board of 24 characters with simple attributes (e.g., hair color, glasses, hat).
– Player can ask yes/no questions using a small input or buttons.
– AI answers based on secret character and eliminates choices visually.
– Allow player to make a final guess.
Return the full HTML/JS code and brief notes on how the AI answers questions.
Use this font and size
Body 16 px, code blocks 14 px, monospace.
Output analysis
The game ran successfully in the browser without errors. All core features worked: characters displayed, questions were asked, eliminations happened correctly, and the reset button restarted the game smoothly.
Some edge cases were handled well. Empty input produced a clear prompt, and unrecognized questions triggered a message asking the user to try supported question types like hair or glasses.
Input validation worked in part. The system checked for empty entries in the question box, and guesses were limited to clicking on characters, which avoided invalid actions. However, more complex natural language questions were not understood because the AI only matched simple keywords.
The logic of the answering system was documented clearly. The notes explained how supported attributes were checked, how eliminations happened, and how errors were handled, which made the design easy to understand.
Accessibility was only partially addressed. The HTML used semantic tags, but it lacked alt text, ARIA labels, and full keyboard navigation support, which limited usability for people relying on assistive tools.
Sample output was provided through browser screenshots and logs. These showed a complete playthrough, including asking questions, narrowing down choices, making a guess, and resetting the game.
Test scorecard
This task met most checks with strong code execution, explanations, and working output. Edge case handling, input validation, and accessibility were partial, which lowers the result to 4/5.
Final words
The Guess Who game is fun, functional, and demonstrates solid use of JavaScript in a single file. With better handling of complex questions and stronger accessibility features, it could be improved further, but as delivered, it is a success and earns 4/5.
Final Words
After eight tests, our takeaway is that Manus AI shows strong ability as a coding partner, but with clear limits. It performed well across basic programming, debugging, algorithm explanation, and front-end generation, proving it can cover a wide range of developer needs.
Its biggest strengths are in generating working code quickly, handling validation in most cases, and explaining fixes or algorithms in ways that are easy to follow. We saw this in the currency converter, debugging task, and bubble sort explanation, all of which were completed cleanly and earned full marks.
Where it fell short was in depth and polish. In some tasks, it skipped explanations, didn’t actually execute the generated code, or only partially handled edge cases and accessibility. The React scaffold, temperature converter, factorial translation, and Guess Who game all worked, but each missed a piece of the KPIs that kept them below a perfect score.
Overall, Manus AI is reliable when you need functional code fast and can trust it with common programming challenges. It still needs human review to catch overlooked details like accessibility, thorough validation, or confirming code execution, but as a tool for scaffolding and testing ideas, it scored highly and proved consistently useful.
