Software Testing Transformation in the AI Era: A Complete Roadmap from Manual Testing to Automation Frameworks

The software testing industry is undergoing a profound transformation. According to a senior test engineer's beginner tutorial on Bilibili, the second half of 2025 through early 2026 has marked a turning point for the entire testing field — nearly every company now expects testers to leverage AI for greater efficiency. This article distills the core content of that tutorial, outlining a complete growth path from functional testing to automated testing to AI-assisted testing.

Salary Tiers and Skill Levels for Test Engineers

Much of the appeal of a testing career comes from its clear progression path and steadily increasing earning potential. Based on recruitment data from Shenzhen, Changsha, and other cities cited in the tutorial, three distinct tiers emerge:

Junior Test Engineer (5–10K RMB): Previously, this role only required writing test cases, using testing tools, and filing bug reports. But the bar has now been raised — at minimum, you need to know one programming language (Python is recommended), be able to write test scripts from scratch, and be familiar with foundational tools like Postman, databases, Nginx, and the HTTP protocol.

Mid-Level Test Development Engineer (20K+ RMB): After three to five years of experience, you're expected to be capable of building interface automation platforms, covering front-end integration testing and back-end end-to-end testing, and being deeply integrated into CI/CD pipelines — including unattended automation with failure notifications and rapid feedback loops.

Senior Test Development Engineer / Test Manager (25–50K RMB): Interestingly, job postings at this level are saturated with AI requirements: building AI-powered test systems, formulating test strategies around AI technology characteristics, and using AI to assist in issue diagnosis — all of these have become hard requirements.

The tutorial's author emphasizes a key point: no matter how technology evolves, the one constant is that things will always change. Even after you land a job, continuous learning remains the defining factor that sets people apart.

Why Functional Testing Matters More in the Age of AI

Many newcomers hold a misconception: now that AI exists, is functional testing irrelevant? The tutorial author argues the opposite — AI's real value is to free up testers so they can invest more energy in understanding business logic and doing functional testing.

Human testers will always be the most reliable option; AI-driven testing carries inherent uncertainty, and humans remain the final reviewers. Core testing types — smoke testing, regression testing, exploratory testing, compatibility testing, and usability testing — are actually worth mastering more deeply than ever.

The author also clarifies a common source of confusion: software testing competency can be broken into three components — theoretical foundations (requirements analysis, writing test cases, filing bugs, writing reports), tooling skills (Linux, databases, programming languages, automation frameworks), and business domain knowledge.

On the anxiety of having "not enough project experience," the author's response is direct: if you know how to use Selenium to identify buttons, input fields, and submit data in an ERP project, you can do the same for a social app — because they all involve buttons and input fields. What's really missing isn't technical skill; it's familiarity with different business domains. Once you've mastered the technical side, pick an app or website you're already familiar with to practice and build business knowledge.

The Underrated Soft Skill: Dealing with People Is the Hardest Part

This is perhaps the most counterintuitive insight in the entire tutorial. The author candidly shares that after years in the field, he finds writing automation code, conducting performance testing, and building test frameworks to be the easy parts — the outcomes are deterministic, requirements are clear, and you're only accountable to yourself. What's truly exhausting is navigating interpersonal dynamics: cross-departmental friction, boundary disputes, and endless back-and-forth over responsibilities.

End-to-end process management and collaboration spans requirements confirmation, test planning, test case design, test execution, defect management, retrospective reporting, and go-live verification. Every step involves communication with different stakeholders:

• Requirements review: You need to voice your own suggestions and discuss scope boundaries with product managers.
• Test planning: You must account for development timelines and release deadlines, while fielding questions like "why does this take so long?"
• Test case review: As the facilitator, you organize efficient reviews and clarify what to test and what requirements are missing.
• Defect management: Understanding the bug lifecycle — deciding which issues can be deferred and how to handle intermittent bugs — is a real skill.
• Retrospective reporting: The test report is one of the few tangible opportunities to demonstrate your value.

The author advises testers to consciously shift from being introverted ("i-type") toward a more outward communication style, since your collaborators often extend well beyond your immediate team to cross-team, cross-company, or even international third-party partners.

Practical Insights: From Agile Workflows to Toolchains

Most consumer-facing internet products operate in agile mode, with two-week sprint cycles being the norm. A high-frequency interview question is: how do you ensure product quality within such a tight cycle? This tests your ability to embed testing into CI/CD pipelines and your mastery of shift-left and shift-right testing — how far left you can push testing directly reflects your capability level and earning potential.

On the tooling side, the tutorial offers practical, no-nonsense recommendations:

• Web: Chrome DevTools for debugging, a packet capture tool (either Charles or Fiddler), cloud-based compatibility testing platforms, and front-end error monitoring.
• Mobile: Performance testing, compatibility testing, and mobile packet capture.
• Databases: Knowing how to perform CRUD operations, work with indexes, and write join queries is sufficient — you don't need to go deep into DBA territory.
• Linux: Focus on what matters in practice: reading logs, checking processes, modifying permissions, and starting/stopping services. Know your way around commands like tail, cat, and ps -ef.
• Interface testing: Postman is fast and lightweight for ad hoc testing; JMeter is better suited for automation and stable execution when embedded in Jenkins pipelines.

For Linux commands, the author offers a useful memorization tip: don't rote-memorize them in isolation — learn them in context. When an interviewer asks about commonly used commands, name the command and follow it with a real scenario: "I use tail -f to stream logs in real time while operating the front end, then export the relevant logs and hand them off to developers after pinpointing the bug." This creates a vivid mental image for the interviewer.

Shift-left and shift-right testing are key concepts for understanding modern test strategy. Shift-left testing means moving test activities earlier — into the requirements analysis and development phases, rather than waiting until code is complete. Catching a logic gap during requirements review, for example, costs far less than finding a bug before release. Shift-right testing means extending testing into production, using live monitoring, A/B testing, and canary releases to continuously validate product quality. Together, they ensure testing coverage across the full software delivery lifecycle. In a two-week agile sprint, how early you can push involvement into requirements directly signals your depth of business understanding and your influence within the team; embedding automated tests into CI/CD pipelines is the practical vehicle for shift-left delivery.

AI-Assisted Testing: The Biggest Advantage for Newcomers

The tutorial author returns repeatedly to one point: AI is actually more beneficial for people who are just entering the testing field. He cites a colleague with nearly twenty years of experience in Java backend development, who observed that junior developers with just one or two years of experience are nearly matching senior engineers in certain areas after adopting AI.

The reason is that AI essentially compresses thousands of years of accumulated human knowledge into a knowledge base, making the experience of predecessors accessible on demand. Tasks like analyzing performance logs and identifying bottlenecks — which once required expert-level architects — can now be performed with AI assistance, as long as you can provide comprehensive, complete data. The prerequisite is that you must understand the fundamentals; otherwise, you won't even know how to use AI properly.

On the topic of "knowing how to use AI," the author draws an important distinction: chatting with a consumer AI assistant or dumping requirements into ChatGPT to generate test cases doesn't count as knowing how to use AI — it's barely more than chatting. Truly knowing how to use AI looks like this:

Using Skills to systematize test case generation. The author demonstrates a five-step test case generation Skills workflow: understand requirements → design → generate test cases → AI self-review (add missing cases, remove non-executable ones) → learning and feedback. When submitting requirements, don't just provide the version 2.0 spec — include the version 1.0 requirements and historical bug records so the AI can perform more comprehensive analysis. After human review, feed that experience back into the AI to create a continuous learning loop.

The author also showcases an AI-powered interface test script generation agent he built: upload an API document and it generates scripts in Postman, JMeter, and Pytest formats, complete with assertions covering normal values, null values, oversized inputs, boundary values, and business logic. Beyond efficiency gains, he points out that the real value of this kind of tool is its ability to be showcased on your résumé and demonstrate individual capability — the same DeepSeek^Ad model call wrapped in a front-end UI agent looks far more polished and engineering-mature than a raw command-line interaction.

Skills, as mentioned in this context, refers to a feature in mainstream AI platforms (such as Coze, Dify, or ChatGPT's custom GPTs) used to solidify specific workflows. By pre-defining role prompts, input templates, processing steps, and output formats, you can ensure that AI handles recurring tasks according to a consistent, standardized process rather than starting from scratch each time. For testing scenarios, this means packaging the entire "requirements analysis → test case design → self-review → feedback iteration" pipeline into a reusable work unit, guaranteeing consistent output quality. This is fundamentally different from pasting requirements into a chat box and hoping the AI improvises something useful — the latter produces unstable results that can't be accumulated as team assets. The former is what the tutorial means by "truly knowing how to use AI."

The Progressive Ladder of Automation and Performance Testing

The automation testing ecosystem centers on Python as the core language (which has only grown more popular since AI took off). Key specializations include UI automation (Playwright has gained traction thanks to AI; Selenium remains the standard at overseas companies), mobile automation, and interface automation, with unit testing being a nice-to-know rather than a must-have. Continuous integration uses Jenkins to build pipelines that go: "commit code → auto deploy → auto test → auto send report."

Notably, the priority of test platform development has been deliberately downgraded in this tutorial — because with Vibe Coding (using AI to assist in building projects), platforms and tooling can be built directly with tools like Cursor. The emphasis has shifted to "mastering the Vibe Coding workflow."

Performance testing is a classic "pay bump" skill set, divided into four levels:

• Beginner: Write scripts in JMeter and run load tests with Locust.
• Intermediate: Design test scenarios and monitor key metrics.
• Advanced: Read full-stack logs across all system layers; understand hardware and middleware.
• Expert: Diagnose and analyze logs, defects, and bottlenecks.

Dedicated performance testing roles are rare; most small-to-mid-sized companies expect one person to cover automation, AI testing, and performance testing combined — the reality of "paying one salary for two roles."

On the choice of AI coding tools, the author's firsthand recommendations are refreshingly practical: Claude Code is powerful but the token costs are prohibitive, it carries account ban risks, and has IP restrictions — not sustainable for individual use. His recommendation is to use Cursor paired with DeepSeek, or Claude Code combined with CC Switch routing to DeepSeek/Kimi for the best cost-to-performance ratio. He personally alternates between Claude Code and Codex, but advises beginners to start with the cost-effective option.

Circling back to career development, soft skills and hard skills carry equal weight: communication and expression, driving issues to resolution, logical thinking, resilience under pressure, the ability to learn and synthesize, and building a personal testing knowledge base that you actively share with others. Sharing your knowledge raises your perceived value and visibility within the team — and takes you further in the long run. For those still doing purely manual "click-and-check" work, the author offers reassurance: most people start out clicking through interfaces, and progress step by step. There's no need to be anxious.

Vibe Coding is a development approach that has emerged alongside the widespread adoption of large language models. It refers to describing your intent in natural language and having AI tools (such as Cursor or Claude Code) generate and iterate on the code, while the developer takes on more of a "requirements provider" and "reviewer" role rather than writing every line by hand. For test engineers, this means that building test platforms and developing automation scripts — tasks that once required a strong programming background — can now have their barriers significantly lowered through Vibe Coding. But the limitations are equally real: the quality of AI-generated code depends heavily on the precision of your prompts, and debugging and maintenance still require the developer to have a baseline understanding of the code. This is exactly why the tutorial repeatedly emphasizes "you must understand the fundamentals, otherwise you won't even know how to use AI properly."