Codestin Search App

Overview

This document summarizes common practices for handling daily development tasks with Qoder CLI—from exploring unfamiliar code, fixing bugs, and refactoring, to writing tests, committing, and reviewing. Each category provides ready-to-use prompt examples that you can adapt to your own projects. All examples are performed in interactive mode. For startup instructions, see Run Tasks.

Exploring and Understanding Code

When facing an unfamiliar codebase, start by having Qoder help you build a high-level understanding:

Help me outline the overall architecture and main modules of this project.
Where is this feature implemented? Which files are involved?
Starting from the entry point, explain clearly how a request is processed.
Where is this function called from?

Qoder will autonomously search the code, read relevant files, and provide explanations with file locations. You can follow up on its responses to dive deeper step by step.

Fixing Bugs

Describe the symptoms and let Qoder locate and fix the issue:

Why is this test failing? Help me fix it.
Run npm test, find the cause of the error, and fix it.
This API occasionally throws errors under concurrent load, help me troubleshoot it.

A safe approach is to have Qoder reproduce the issue and explain the root cause before making any changes. For issues with a broader impact, you can use Plan to confirm the approach first; see Plan Before Execution (Plan).

Refactoring

Refactoring often involves multiple files. Clearly describe your goals and constraints:

Extract the date handling functions in utils into a separate module and update all references
Unify the error handling approach in this directory while keeping the external behavior unchanged
Refactor these callbacks to use async/await, making sure not to change the underlying logic

It is recommended to run tests and perform a code review before and after refactoring to ensure behavior remains unchanged; see Viewing and Reviewing Code Changes. For larger-scale refactoring, it is best to use Plan to outline the approach first.

Implementing Features

Let Qoder write code based on your requirements:

Implement an Express middleware for request rate limiting
Complete the corresponding client methods according to this API documentation
Add form validation and error messages to this page

Qoder supports multimodal input. You can attach design mockups or screenshots and have it generate code accordingly.

Writing and Running Tests

Add unit tests to this module, covering the main branches
Write a regression test for the recent changes
Run the tests and fix the failing cases

Having Qoder proactively run tests after writing code creates a closed loop of implementation, verification, and correction. To have it continuously fix issues until all tests pass, you can use Goal; see Continuously Achieving Goals (Goal).

Commits and PRs

Generate a commit message for these changes
Split the related changes into multiple semantically clear commits
Summarize the changes in this branch compared to main, and write a PR description

When performing Git operations, Qoder will request confirmation before execution based on your permission settings. For details on permission control, see Permissions.

Code Review

Review your changes before committing:

Review my current changes and identify potential issues
Compare with the main branch and review this feature branch

You can also directly use /review to select the scope of the review; see Viewing and Reviewing Code Changes.

Tips

Clearly describe goals and constraints: Specifying what you want and what you do not want changed can significantly improve the quality of the results.
Focus on one thing at a time: Breaking complex tasks into steps is more manageable than describing all requirements at once.
Leverage project instructions: Document your project conventions in AGENTS.md, and Qoder will follow them in every session; see Memory.
Large Codebases: For practices tailored to large repositories and Monorepos, see Best Practices for Large Codebases.

​Overview

​Exploring and Understanding Code

​Fixing Bugs

​Refactoring

​Implementing Features

​Writing and Running Tests

​Commits and PRs

​Code Review

​Tips