The emergence of sophisticated AI code editors, exemplified by Cursor, marks a significant inflection point in software development. By integrating large language models directly into the integrated development environment (IDE), these tools promise to automate tedious tasks, accelerate complex refactoring, and fundamentally elevate the role of the developer. However, this leap in individual productivity has simultaneously exposed the profound and systemic limitations of the traditional local development environment. The very power that makes Cursor revolutionary—its ability to index and comprehend entire codebases, execute complex tasks via autonomous agents, and provide real-time, context-aware assistance—imposes a resource demand that standard-issue laptops cannot consistently meet. This creates a performance bottleneck that throttles the AI's potential and perpetuates classic development frustrations like configuration drift and the "works on my machine" paradox.  

The optimal "Cursor DevBox" experience is not achieved by simply running the Cursor application on a generic cloud virtual machine. Instead, it requires a paradigm shift towards a purpose-built Cloud Development Environment (CDE). The analysis demonstrates that Sealos DevBox, a CDE built on a Kubernetes-native cloud operating system, represents this necessary evolution. By providing instant, perfectly reproducible, and scalable development environments with seamless, one-click integration into the Cursor IDE , Sealos DevBox resolves the foundational constraints of local and generic remote setups. This synergy does more than just provide a more powerful backend; it creates a multiplier effect. Sealos DevBox unleashes the full potential of Cursor's advanced AI capabilities, providing a high-fidelity, production-parity foundation that enhances the accuracy and reliability of the AI itself. This transforms the entire software development lifecycle from a series of disjointed, friction-filled steps into a unified, high-velocity, and truly AI-native workflow.  

For decades, the local development environment has been the undisputed standard for software engineering. The model's appeal was rooted in its promise of control, autonomy, and the ability to work offline. Developers could meticulously configure their personal machines, installing the precise tools and libraries needed for their projects. This paradigm, however, was forged in a simpler era of monolithic applications and smaller, more contained codebases. The architecture of modern software—characterized by distributed microservices, complex dependency graphs, and massive monorepos—has placed this legacy model under unbearable stress, revealing its inherent fragility. The result is a collection of systemic failures that impose a hidden but substantial tax on engineering productivity and morale.  

The Modern Reality: A Paradigm Under Stress

The breakdown of the local development model manifests in several recurring and costly problems that plague engineering organizations. These are not isolated incidents of user error but predictable outcomes of an outdated system struggling to cope with modern demands.

• "Dependency Hell" and Configuration Drift: A primary source of friction is the management of dependencies. Each developer's machine evolves into a unique "snowflake" environment over time, with subtle differences in operating system patches, library versions, and configuration files. This "configuration drift" makes it nearly impossible to ensure a uniform development environment across a team, leading to a state commonly known as "dependency hell," where resolving version conflicts becomes a time-consuming and frustrating task.  

• The "Works on My Machine" Paradox: This infamous statement is the direct and inevitable consequence of configuration drift. Code that functions perfectly on one developer's machine fails unexpectedly on another's or, more critically, in the staging or production environment. The time lost debugging these environment-specific issues is immense, eroding team velocity, undermining confidence in deployments, and creating a culture of frustration. It is a clear signal that the development environment itself has become a source of bugs.  

• Onboarding Friction and Team Inefficiency: The initial setup of a local development environment for a complex project can take a new team member days, or even weeks. They must navigate outdated documentation, consult multiple team members, and troubleshoot a litany of installation and configuration issues. This extended onboarding period represents a significant loss of productivity and a frustrating first experience for new hires, delaying their ability to contribute value.  

• Resource Ceilings: The physical limitations of a laptop are a hard ceiling on the complexity of applications that can be developed locally. Modern stacks often require running multiple microservices, databases, and a local Kubernetes cluster (such as minikube or Docker Desktop), all of which consume significant memory and CPU cycles. Developers on standard-issue hardware frequently encounter performance degradation, system crashes, and the inability to run the full application stack, forcing them to rely on incomplete or mocked environments.  

The AI Accelerator as the Tipping Point

This already fragile system has been pushed to its breaking point by the arrival of the latest generation of AI development tools. AI-powered code editors like Cursor are not lightweight plugins; they are computationally intensive applications that demand significant resources to deliver on their promise. Their core value lies in their ability to perform deep, codebase-wide analysis, maintain a large context window, and run powerful models to generate and refactor code.  

When an AI agent needs to scan a million-line codebase to plan a refactor, it places an unprecedented load on the local machine's CPU and I/O systems. The very features that make these tools revolutionary are the same ones that overwhelm the capacity of a typical developer's laptop. Therefore, the introduction of powerful AI assistants is the final straw, making the limitations of the local development model not just an inconvenience but a fundamental barrier to adopting the next wave of productivity tools. The incompatibility between the demands of modern, AI-assisted software development and the capabilities of the traditional local environment necessitates a paradigm shift.

In a landscape crowded with developer tools, Cursor has emerged not merely as another code editor but as a fundamental reimagining of the IDE itself. Developed by Anysphere Inc. and first released in 2023, Cursor is purpose-built for an era of AI-native development. While it is engineered as a fork of the ubiquitous Visual Studio Code—a strategic choice that ensures a familiar interface and grants immediate access to a vast ecosystem of extensions, themes, and keybindings—its true innovation lies in the deep, seamless integration of advanced AI capabilities. This design philosophy positions Cursor to act less like a passive tool and more like an active, intelligent collaborator in the coding process.  

Core Capabilities: A Deep Dive into the "Magic"

Cursor's power stems from a suite of tightly integrated features that work in concert to understand context, automate tasks, and accelerate the entire development workflow.

• Codebase-Wide Context: This is arguably Cursor's most transformative feature. Unlike many AI assistants that operate with the limited context of a single open file, Cursor is designed to index and comprehend an entire project. It builds a semantic understanding of the whole codebase, allowing it to provide highly relevant answers and perform complex edits that span multiple files. Developers can use simple @ mentions to reference specific files, folders, or code symbols, manually guiding the AI's focus without the tedious process of copying and pasting context into a chat window. This capability is powered by custom retrieval models that intelligently pull in the necessary information, whether from local files, external documentation, or even web searches using @Web.

• "Agent Mode" and Proactive Assistance: Cursor's "Agent Mode" elevates the AI from a simple code completion tool to a proactive assistant capable of planning and executing complex tasks from end to end. When a developer issues a high-level instruction, such as "Refactor this feature to use the new authentication service," the Agent can devise a multi-step plan, identify the relevant files across the codebase, write and run necessary terminal commands, and even detect and attempt to fix linting errors along the way. This shifts the developer's role from performing the work to directing the work, maintaining full control and visibility while being freed from the repetitive, mechanical aspects of coding.  

• Intelligent and Predictive Editing: At the micro-level of writing code, Cursor introduces features designed to reduce cognitive load and increase velocity. Its predictive autocomplete can suggest multi-line edits, anticipating the developer's intent based on recent changes. This "Tab, Tab, Tab" workflow allows developers to breeze through repetitive changes across files. Furthermore, its "Smart Rewrites" feature can automatically correct typos and improve carelessly written code, reducing the friction between thought and implementation.  

• Integrated Chat and Code Generation: The built-in chat interface, accessible via a shortcut like Ctrl+K, is the central hub for interaction. It is not a generic chatbot but an AI that is deeply aware of the project's context. Developers can use it to ask questions ("Is there a bug here?"), generate new code from scratch ("Create a React component with these props"), or refactor existing code blocks with natural language prompts. The AI's suggestions are presented as a clear diff, which can be applied to the codebase with a single click, creating a seamless and conversational coding experience.  

The Voice of the Developer: Credibility Through Acclaim

The efficacy of Cursor is not just theoretical; it is validated by widespread adoption and praise from developers at the world's leading technology companies. Engineers from organizations like Instacart, OpenAI, Figma, Notion, and Google have lauded Cursor as a significant workflow improvement, with some describing it as a "2x improvement over Copilot" and a "necessity" for writing code. This positive sentiment is mirrored in the enterprise sector, where over 50,000 organizations, including 53% of Fortune 1000 companies, have chosen Cursor as their IDE. Customer testimonials highlight dramatic productivity gains, with one firm reporting that over 45% of their code changes are now fully written by AI, and another seeing a 50% increase in shipped code after switching from GitHub Copilot, which had struggled to achieve even 20% adoption. This broad appeal extends to academia, where students and researchers at institutions like Harvard, Stanford, and CMU use Cursor to accelerate research, learn new frameworks, and build startup prototypes at an unprecedented pace.  

The Inherent Limitation

Despite its revolutionary capabilities and proven impact, Cursor's power is ultimately tethered to the environment in which it operates. All of its sophisticated analysis, model inference, and task execution run on the developer's local machine. This creates a direct dependency on the available hardware. A developer's experience with Cursor's speed and responsiveness is directly proportional to the power of their computer. This dependency establishes a critical bottleneck, where the full potential of this advanced AI software is constrained by the physical limitations of the local environment, foreshadowing the need for a more robust and scalable solution. The very success of Cursor's features creates a new, more acute need for an environment that can match its ambition. A powerful engine requires a sturdy chassis and high-octane fuel to perform; for Cursor, the local machine is often not enough.

As software projects grow in complexity, the need to leverage computational resources beyond the local machine becomes unavoidable. Recognizing this, the developers of Cursor have ensured it supports remote development, allowing it to connect to more powerful servers where the actual coding and processing can take place. This capability is the logical next step for any developer hitting the resource ceiling of their laptop. However, the standard approach to this remote connection, while functional, reveals a deeper set of challenges related to environmental management and consistency.

Cursor's Standard Approach: The Remote - SSH Extension

As a fork of VS Code, Cursor inherits its robust and well-established mechanism for remote development: the Remote - SSH extension. This extension enables a powerful workflow where the Cursor client runs locally on the developer's machine, providing the user interface, while all development operations—such as file editing, terminal commands, and debugging—are executed on a remote server over a Secure Shell (SSH) connection.  

The setup process is straightforward for a developer familiar with SSH protocols. It typically involves :  

1. Installing the Remote - SSH extension from the marketplace within Cursor.

2. Configuring an SSH host by adding an entry to the local SSH configuration file (e.g., ~/.ssh/config), specifying the remote server's address, user, and authentication method.

3. Initiating a connection from Cursor, which then installs a lightweight server component on the remote machine and opens a new window connected to that environment.

This functionality is essential and provides immense flexibility, allowing Cursor to be used with a wide array of backends, from a simple virtual machine on a cloud provider to more structured platforms like Diploi or DevPod. It effectively solves the problem of insufficient local CPU and RAM.  

The Hidden Complexities of Generic SSH

While connecting to a remote server via SSH addresses the issue of raw computational power, it does not solve the more fundamental problems of environmental management. In fact, it can often just relocate them. This generic approach carries several hidden complexities that continue to introduce friction into the development process.

• The Management Burden: The developer, or their organization, is still fully responsible for provisioning, configuring, patching, and maintaining the remote server. The "snowflake" environment problem is not eliminated; it is merely moved from the developer's laptop to a server in a data center. Each remote server can become just as unique and brittle as a local machine if not managed with rigorous discipline.  

• Configuration Hell: The process is fraught with potential configuration errors. Developers must manually manage SSH keys, ensure permissions are correct, and troubleshoot network connectivity issues. As evidenced by numerous community forum posts, developers frequently encounter problems with incompatible extension versions, 404 errors when the remote server tries to download components, and other connection failures that require significant debugging to resolve. This manual, error-prone setup process is a persistent source of frustration.  

• Lack of Integration: A generic remote server is a "dumb" environment. It is simply a machine running an operating system. It has no intrinsic awareness of the broader development lifecycle. Databases, caching layers, message queues, and deployment pipelines are all separate systems that must be manually configured and integrated. This lack of a unified platform means the developer is still context-switching between different tools and interfaces to manage their full workflow.  

• The "Remote Desktop" Anti-Pattern: The complexity of setting up a headless remote environment leads some users to adopt an even more cumbersome workaround: installing a full graphical desktop environment (like XFCE) on a cloud server and accessing it via a remote desktop protocol like VNC or RDP. This approach is highly inefficient, consuming unnecessary resources and providing a clunky, high-latency user experience. It is a clear indicator that existing solutions are failing to meet developer needs in an elegant way.  

Ultimately, standard SSH connectivity is a feature, not a comprehensive solution. It effectively treats the symptom—a lack of local processing power—but fails to address the underlying disease of brittle, inconsistent, and manually managed development environments. It relocates the problem without solving its root cause, creating a significant value gap that only a more integrated, purpose-built platform can fill.

The inherent limitations of both local and generic remote development setups highlight the need for a new approach—one that treats the development environment not as a manually curated "pet" but as a disposable, version-controlled, and instantly reproducible product. This is the core philosophy behind Sealos and its flagship development product, DevBox. Sealos positions itself as a cloud operating system designed to abstract away the immense complexity of modern cloud-native infrastructure, particularly Kubernetes. It aims to solve the primary challenges developers face with traditional cloud platforms: crushing costs, overwhelming complexity, and slow time-to-market.  

DevBox: The Development Environment Reimagined

Within the broader Sealos ecosystem, DevBox is the service that directly addresses the pain points of environment management. It is a Cloud Development Environment (CDE) that provides ready-to-code, cloud-based workstations designed to eliminate friction and accelerate the entire development lifecycle. Its architecture is built on several key principles:  

• Instant Provisioning: DevBox environments can be spun up in under 60 seconds. This stands in stark contrast to the days or even weeks required to set up a traditional local environment. This speed is achieved by using pre-configured templates that contain all the necessary runtimes and dependencies for a given technology stack.  

• Reproducible and Isolated: At its core, DevBox is built on containers and powered by Kubernetes. This architecture ensures that every development environment is 100% reproducible and perfectly isolated from others. This completely eliminates configuration drift and the "works on my machine" problem, guaranteeing that every developer on a team is working in an identical setup.  

• Pre-configured and Ready-to-Code: DevBox offers a library of templates for a wide range of popular frameworks and languages, including Next.js, Python with FastAPI, Go, Rust, and the MERN stack. When a developer creates a DevBox from a template, it comes with all the necessary dependencies pre-installed, removing all setup friction and allowing them to start coding immediately.  

• Powered by Kubernetes, Without the Complexity: A key value proposition of Sealos is that it harnesses the power of Kubernetes for scalability, resilience, and orchestration while completely abstracting away its notorious complexity. Developers gain the benefits of a robust, production-grade platform without needing to become Kubernetes experts or write hundreds of lines of complex YAML configuration files.  

The Seamless IDE Connection

Perhaps the most critical feature for a developer using an editor like Cursor is the bridge between their local IDE and the remote environment. Sealos DevBox makes this connection uniquely seamless and frictionless. Instead of requiring manual SSH configuration, DevBox provides a "one-click" connection process directly from its web-based dashboard.  

When a developer clicks the "Cursor" button next to their project, an automated flow is triggered :  

1. The local Cursor IDE is launched.

2. The system prompts the user to install the lightweight DevBox plugin (a one-time setup).

3. The plugin automatically configures the necessary SSH host details in the background and establishes a secure, authenticated connection.

This automated process removes all manual steps and potential points of error, such as managing SSH keys or debugging connection issues, which are common pain points with generic SSH setups. The developer is left with a fast, stable, and effortless connection to their powerful cloud environment.  

To crystallize the advantages of this model, the following table provides a direct comparison between the traditional local development paradigm and the Sealos DevBox solution.

  This shift in approach is profound. Sealos DevBox is not merely offering "hosting"; it provides a fully managed, opinionated platform that productizes the development environment itself. By treating environments as disposable, version-controlled assets that can be created and destroyed on demand, it solves the root causes of inconsistency and management overhead, offering a fundamentally superior model to the manually curated, brittle environments of the past.

Combining a revolutionary AI code editor like Cursor with a next-generation Cloud Development Environment like Sealos DevBox creates a result far greater than the sum of its parts. This synergy produces a powerful multiplier effect, where each component enhances the capabilities of the other, leading to a development experience that is faster, more intelligent, and more reliable. Sealos DevBox provides the ideal foundation—the stable, high-performance "stadium"—that allows the "superstar athlete" that is Cursor to perform at its absolute peak, unconstrained by the limitations of a local machine.

Synergy in Action: How DevBox Amplifies Cursor

The combination of these two technologies creates tangible benefits that address the core challenges of modern software development. The stable and powerful backend provided by DevBox directly amplifies the effectiveness of Cursor's most advanced AI features.

• Unleashing the Agent: Cursor's Agent Mode is one of its most powerful features, capable of executing complex, multi-file refactors or generating entire application features from a single prompt. When run on a local machine, these long-running tasks can consume all available CPU and RAM, slowing the entire system to a crawl and preventing the developer from performing other work. On a scalable Sealos DevBox, the Agent can be unleashed on massive monorepos, executing its tasks on powerful cloud servers without impacting the developer's local machine performance in the slightest. This enables truly ambitious, asynchronous tasks like large-scale migrations or comprehensive test suite generation, which would be impractical to run locally.  

• Supercharging Codebase Analysis: Cursor's ability to provide codebase-wide context is fundamental to its intelligence. However, the initial process of indexing the code and performing semantic searches is I/O and CPU-intensive. On a local machine with a standard SSD and limited processing cores, this can be a slow process, especially for enterprise-scale projects with millions of lines of code. When running on a Sealos DevBox, which is backed by high-speed cloud storage and powerful CPUs, this analysis becomes near-instantaneous. The AI can comprehend the entire project context much more quickly, leading to faster, more accurate responses from the chat and Agent.  

• Flawless Debugging and Testing: A primary cause of bugs slipping into production is the discrepancy between development and production environments. A developer can use Cursor's AI-powered debugging features to fix an issue, only to find the fix doesn't work in production because of a subtle difference in a library version or OS configuration. By using Cursor within a Sealos DevBox, developers are debugging and testing in an environment that is a perfect, 100% reproducible replica of production. This eliminates an entire class of environment-specific bugs. Consequently, the AI's suggestions for bug fixes are far more accurate and reliable because they are generated within a high-fidelity context that matches the deployment target.  

• Collaborative AI-Powered Development: Sealos DevBox facilitates a new paradigm for team collaboration. Multiple developers can connect their individual Cursor instances to the same shared DevBox environment. When one developer uses Cursor's Agent to refactor a component, the changes are instantly reflected in the shared environment and become available to the rest of the team. This enables a novel form of real-time, AI-assisted pair programming and code review, all taking place within a single, consistent, and centralized environment, dramatically improving team velocity and reducing integration friction.  

The following table details the specific synergistic effects, illustrating how Sealos DevBox directly enhances Cursor's core AI functionalities.

  This powerful combination creates a "closed-loop" development system. The quality of any AI model's output is directly proportional to the quality and completeness of the context it is given. This context includes not just the source code but the entire environment: the operating system, dependency versions, network configurations, and connected services. A local environment is an inherently imperfect, low-fidelity representation of production. AI-generated code produced in this context may contain subtle errors or security vulnerabilities that only manifest when deployed. In contrast, a Sealos DevBox provides a high-fidelity, production-parity environment. By running Cursor on DevBox, the AI operates with the best possible context, leading to higher-quality, more reliable, and more secure code suggestions. The environment improves the AI, and the AI improves the code, creating a virtuous cycle that elevates the entire development process.  

To move from abstract benefits to concrete reality, this chapter provides a narrative walkthrough of a complete, end-to-end development workflow. This story illustrates how a developer can leverage the combined power of Cursor and Sealos DevBox to go from an idea to a globally deployed feature in minutes, without ever touching complex infrastructure configurations.

Step 1: Project Creation (The 60-Second Start)

The journey begins in the Sealos Cloud dashboard. A developer on a new project needs to set up their environment. Instead of following a lengthy README and installing dozens of dependencies locally, they perform the following actions:  

1. Navigate to the DevBox application within the Sealos dashboard.

2. Click "Create Project" and select a pre-configured template from the library. For this example, they choose the Next.js template, which comes with Node.js, npm, and all necessary build tools pre-installed.  

3. They give the project a name and confirm the resource allocation (e.g., 2 CPU cores, 4GB memory).

Within approximately 60 seconds, Sealos provisions a new, isolated, container-based development environment. The setup phase, which traditionally takes hours or days, is complete before they can finish a cup of coffee.

Step 2: Connecting the IDE (The One-Click Bridge)

With the environment running, the developer needs to connect their preferred IDE. In the DevBox project list, they see their newly created project.

1. In the "Operation" column for their project, they click on the dropdown menu next to the IDE icons.

2. From the menu, they select "Cursor".  

This single click initiates an automated sequence. Their local Cursor application launches, and if it's the first time connecting, it prompts them to install the lightweight Sealos DevBox plugin. The plugin then handles all SSH key and configuration management in the background, seamlessly establishing a secure remote connection. The developer is now looking at their familiar Cursor interface, but the integrated terminal, file system, and all code execution are happening entirely within their powerful and consistent cloud-based DevBox.  

Step 3: AI-Powered Development (The Creative Flow)

Now in the creative "inner loop," the developer begins to build.

1. They want to add a simple health check endpoint to their application. Instead of manually creating the file and writing boilerplate code, they use Cursor's chat feature by pressing Ctrl+K.

2. They type a natural language prompt: "Create a new API route in /pages/api called status.js. It should export a default handler that returns a JSON object with a status of 'ok' and the current server timestamp.".  

3. Cursor's Agent understands the request, generates the correct Next.js API route code, and creates the new status.js file in the correct directory. The developer reviews the generated code in a diff view and accepts the change with a click.

4. To test the change, they open the integrated terminal within Cursor—which is a shell session inside the DevBox—and run the command npm run dev. The Next.js development server starts up.  

5. Sealos DevBox has automatically exposed the application's port (e.g., port 3000) to the internet via a secure, public URL. The developer clicks this URL in their Sealos dashboard, navigates to /api/status, and instantly sees the JSON response from their newly created endpoint, verifying that it works correctly.

Step 4: Release and Deploy (The Integrated Finish Line)

Satisfied that the new feature is working, the developer is ready to deploy it. This is where the workflow transitions seamlessly from the inner loop to the "outer loop" of CI/CD, all within the same platform.

1. In the Cursor terminal, they commit their changes to their Git repository using standard commands.

2. They navigate back to their project's details page in the Sealos dashboard. In the "Version" section, they click the "Release" button.  

3. A dialog appears, prompting for a version tag (e.g., v1.1.0) and a description. Upon confirmation, Sealos automatically builds the project and packages it into a versioned, OCI-compliant container image—the standard unit of deployment in modern cloud environments.  

4. Once the release is created, a "Deploy" button appears next to it. Clicking this button takes the developer to the Sealos App Launchpad.  

5. The App Launchpad provides a simple interface to configure the production deployment. Since the application was built from a standard template, most settings are pre-filled. The developer confirms the settings and clicks "Deploy Application."

Sealos's underlying Kubernetes engine then handles the entire deployment process: scheduling the container, managing network routing, and exposing the application to the public via a production-ready domain with automatic SSL. In a matter of minutes, the developer has gone from a natural language prompt to a globally deployed, live feature, without writing a single line of YAML or interacting with complex cloud infrastructure.  

This unified workflow demonstrates a powerful integration between the development and deployment phases. The environment used for coding (the DevBox) is the direct precursor to the immutable container image used for production, ensuring an unprecedented level of consistency and reliability. By providing a single, coherent platform for this entire lifecycle, the combination of Cursor and Sealos eliminates the friction that traditionally exists at the boundary between development and operations, dramatically accelerating the entire code-to-cloud journey.

This leads to an unequivocal conclusion: the advent of revolutionary AI-powered IDEs like Cursor has rendered the traditional local development environment obsolete. While these intelligent tools represent a monumental leap forward in developer productivity, they are only one half of the equation. Their true, transformative power is only unlocked when they are freed from the resource constraints and inconsistencies of the local machine and paired with a Cloud Development Environment that provides a stable, scalable, and production-parity foundation.

The ideal "Cursor DevBox" is therefore not a product but a strategic pairing: the synergistic combination of Cursor's intelligent, context-aware development interface and Sealos DevBox's powerful, integrated, and frictionless cloud-native backend. This combination represents the next logical and necessary evolutionary step in software development. It resolves the fundamental flaws of the old paradigm—the "works on my machine" paradox, dependency hell, and resource ceilings—while creating a virtuous cycle where the high-fidelity environment enhances the AI's performance, and the AI, in turn, accelerates the creation of high-quality code.

The implications of adopting this model extend beyond individual productivity. For engineering organizations, it translates to faster developer onboarding, significantly reduced operational overhead, and a more secure and standardized development practice. For the business, it means an accelerated time-to-market for new features and a more agile, responsive, and satisfied engineering team capable of tackling complex challenges without being bogged down by environmental friction. The future of software development is one where developers act as architects, directing intelligent agents in powerful, cloud-powered environments.  

Stop wrestling with your local environment and unlock the full potential of AI-native development. Experience the true "Cursor DevBox" workflow today by creating your first environment on Sealos.