Advanced practical scenario · Scenario 2

Quickly get familiar with a new company’s project

Master a systematic way to quickly understand new projects, from code reading to project comprehension, from rapid onboarding to knowledge accumulation. Use AI tools to speed up code reading and understanding, and quickly integrate into a new team.

Learning objectives

Master a systematic method for quickly understanding new projects
Able to use AI tools to speed up code reading and understanding
Has the ability to accumulate and share knowledge
Understand the project understanding framework (business understanding → architecture understanding → code understanding)

Methodology

Code reading strategy

Top-down (Top-Down)

  • • Applicable scenarios: Need to quickly understand the overall architecture and business processes
  • • Reading order: README → architecture docs → entry file → main modules → specific implementation
  • • Advantages: Quickly build an overall understanding and grasp the business logic

Bottom-Up

  • • Applicable scenarios: Need to deeply understand a specific feature or module
  • • Reading order: specific implementation → module interfaces → module dependencies → overall architecture
  • • Advantages: Gain a deep understanding of implementation details and master technical specifics

AI tool applications: Use Windsurf’s Fast Context or Cursor Agent to quickly understand the overall structure and key modules of a large codebase.

Project understanding framework

1
Business understanding: Understand business goals, user needs, business processes, and business rules
  • • Read product docs, requirements docs, and user stories
  • • Understand business models and data models
  • • Use AI tools: NotebookLM to organize business documents
2
Architecture understanding: Understand the system architecture, module division, tech stack, and data flow
  • • Read architecture documents, technical documents
  • • Understand module dependencies and data flow
  • • Using AI tools: Windsurf analyzes the code structure, Cursor Agent generates architecture diagrams
3
Code understanding: Understand code structure, key implementations, design patterns, and best practices
  • • Read key code and understand the implementation logic
  • • Understand code style and design patterns
  • • Use AI tools: Cursor Agent code Q&A, Zread code analysis

Quick start workflow

Phase 1: Document reading (1-2 days)

  • • Read README, architecture docs, API docs
  • • Understand project goals, tech stack, and development process
  • • Use AI tools: NotebookLM to organize documents, Fabric to generate summaries

Stage 2: code exploration (2–3 days)

  • • Run the project and understand the startup flow
  • • Explore key modules and understand the code structure
  • • Use AI tools: Windsurf for quick understanding, Cursor Agent for code Q&A

Phase 3: Small feature development (3-5 days)

  • • Choose a small feature to develop
  • • Understand the development process, coding standards, and testing requirements
  • • Use AI tools: Cursor Agent for development assistance and code review

Phase 4: Refactoring optimization (ongoing)

  • • Discover code issues and provide optimization suggestions
  • • Refactor code to improve code quality
  • • Use AI tools: Cursor Agent code optimization, refactoring suggestions

Methods for accumulating knowledge

Notes and Documents

  • • Study notes: record key concepts, architectural designs, code patterns
  • • Issue log：Record the problems encountered and the solutions
  • • Best practices: Summarize the best practices and design patterns in the project

Skill/Pattern creation

  • • Cursor Skill: Encapsulate project-specific development patterns as a Skill
  • • Fabric Pattern: Encapsulate common code patterns as Patterns
  • • Team sharing: Skills and Patterns can be shared and reused within the team

Knowledge sharing

  • • Technical sharing: Share learning takeaways and best practices within the team
  • • Document update: Update the project documentation and fill in missing information
  • • Code review: Learn and share knowledge through code review

AI tool applications

Use Windsurf's Fast Context to quickly understand large codebases

Windsurf's Fast Context technology can quickly analyze large codebases and understand the overall structure:

  • • Quick index: automatically index the entire codebase and build a code map
  • • Smart search: Quickly search related code and files
  • • Context understanding：Understand the dependencies and data flow between code
  • • Architecture analysis: Automatically analyze system architecture and module partitioning

Use Cursor Agent for code exploration and Q&A

Use Cursor's Agent mode to understand code through Q&A:

Example question:

  • • "What does this function do?"
  • • “Which other modules does this module depend on?”
  • • "How does data flow from the API to the UI?"
  • • "What is this design pattern? Why is it designed this way?"
  • • AI analyzes the code and answers your questions
  • • You can ask follow-up questions in depth and understand implementation details
  • • Generate code comments and documentation

Use Zread to analyze GitHub repositories

Zread can quickly analyze GitHub repositories and understand the project structure:

  • • Repository overview：Quickly understand the project structure, tech stack, and dependencies
  • • Code analysis: Analyze code quality, complexity, and design patterns
  • • Commit history: understand the project evolution history and key changes
  • • Problem identification: identify potential issues and areas for improvement

Use NotebookLM for document organization and knowledge extraction

NotebookLM can organize project documents and extract key information:

  • • Document import: Import README, architecture documentation, API documentation
  • • Knowledge extraction: Automatically extract key concepts, architectural design, and API interfaces
  • • Q&A system: answer questions based on document content
  • • Knowledge summary: generate project overview and knowledge graph

Use Fabric to generate code summaries

Use Fabric's Patterns to automatically generate code summaries:

  • • Code summarization: automatically generate summaries of functions, modules, and files
  • • Architecture document: Generate architecture documentation based on code
  • • API documentation: Generate API documentation based on code comments
  • • Study notes: Generate study notes and knowledge summaries

Practical case study

Case 1: Quickly get familiar with a Monorepo project

Project features

  • • Monorepo structure containing multiple packages and services
  • • Use pnpm workspaces to manage dependencies
  • • Massive codebase with complex inter-module dependencies

Step 1: Use Windsurf to quickly understand the structure (1 day)

  • • Open Windsurf and load the entire Monorepo
  • • Use Fast Context to analyze the project structure
  • • Understand the dependencies between packages
  • • Identify core packages and key modules

Step 2: Use Cursor Agent to explore key modules (2 days)

  • • Select the core packages and use Cursor Agent for code Q&A
  • • Understand the responsibilities and interfaces of modules
  • • Understand the data flow and call chain
  • • Generate module documentation and architecture diagrams

Step 3: Develop a small feature (3 days)

  • • Choose a small feature to develop
  • • Understand the development workflow and code conventions
  • • Use Cursor Agent to assist development
  • • Submit code and conduct code review

Step 4: Knowledge accumulation (ongoing)

  • • Create a Cursor Skill to encapsulate project-specific development patterns
  • • Update project documentation and fill in missing information
  • • Share learnings within the team

Case 2: Quickly get familiar with a legacy system

Project features

  • • Legacy systems, inconsistent code quality
  • • Documentation is missing or incomplete
  • • The tech stack is older and requires understanding the historical design

Step 1: Use Zread to analyze the GitHub repository (half a day)

  • • Use Zread to analyze the repository structure
  • • Understand the tech stack and dependencies
  • • Review commit history to understand the project's evolution
  • • Identify key files and modules

Step 2: Use NotebookLM to organize the documents (1 day)

  • • Import existing documents and README
  • • Use NotebookLM to extract key information
  • • Generate project overview and knowledge graph
  • • Q&A based on document content

Step 3: Use Cursor Agent to understand the code (2–3 days)

  • • Select key modules and use Cursor Agent for code Q&A
  • • Understand business logic and implementation details
  • • Identify code issues and areas for improvement
  • • Generate code comments and documentation

Step 4: Refactoring and optimization (ongoing)

  • • Identify code issues and suggest refactoring improvements
  • • Use Cursor Agent to assist with refactoring
  • • Update the documentation and record the refactoring process
  • • Create best practices documentation

Learning outcomes checklist

Master code reading strategies (top-down vs. bottom-up) and choose the appropriate strategy based on the situation
Understand the project understanding framework (business understanding → architecture understanding → code understanding) and be able to systematically understand new projects.
Master the quick-start workflow (document reading → code exploration → small feature development → refactoring optimization)
Able to quickly understand large codebases using Windsurf's Fast Context
Be able to use Cursor Agent for code exploration and Q&A
Able to analyze GitHub repositories using Zread
Able to use NotebookLM and Fabric for document organization and knowledge extraction
Have the ability to accumulate and share knowledge, create Skills/Patterns, and update documentation
Complete at least one practical case (Monorepo project or legacy system)