Is anyone using cloud dev environments (e.g. Codespaces/Replit) at work?

We at Instacart use them heavily. It is a system my team built called Bento Remote ("Bento" is a local orchestration tool we previously built). We built Bento Remote ourselves because Codespaces was in its infancy at the time and really couldn't meet our needs for things like pre-built images, preserved disks, warm pools, live patching, and being behind our firewall. Bento Remote was and is hugely successful and likely one of the largest boosts to developer productivity in our history.

With Bento Remote get a fresh new fully dedicated EC2 machine in about two minutes from when you run `bento remote create`. It is continuously tested on every merge and verified to function. Everything you need is preinstalled and ready to go. Just connect VSCode to it and start coding. No futzing around getting your local environment to work. Break something on your Bento Remote? Throw it away and get a new machine. Switching projects? Grab a new machine from the pool that is preconfigured for that project. Your settings travel with you.

We had a potentially unique set of circumstances though. Our full stack development requirements were VERY high and needed 64GB to even run our largest and most active apps. This made other 3rd party tools fantastically expensive. Building it ourselves let us fit instacart specific needs and workflows. As well as do clever things like hibernating the EC2 instance after hours when the users laptop is idle. This plus a host of other measures were essential to making this not only cost effective but a large net gain.

So I highly recommend everyone at least take a look and evaluate if you have the need. Start with the SaaS versions and see.

Plenty of large companies are using them (I'm talking Google/FB/Microsoft and the like). You may not have heard of it because they run these systems in-house vs using a commercial service.

My company switched to 100% remote dev envs a couple years ago. When you cut a branch it spins up a VM and you can connect to it from VS Code (native or browser based) or just plain SSH. It works great. The lag is not noticeable at all. Dev envs are fully provisioned and up to date with all tooling and dependencies so you don't need to bother with managing any of it locally. Given a choice I don't think any dev at my company would go back.

We are an agency where you might flip between working on several completely different projects in a week, and for us it's extremely useful.

We'd had all our sites set up to run fairly easily via docker compose prior, but I'd still find myself debugging people's setups fairly frequently. And giving developers data and secrets was often either insecure or complicated, depending on the codebase.

With codespaces, people can just jump straight into a working project, without pulling any client code or secrets or data onto their machine. It still requires maintenance sometimes but at least when I fix the codespace config I know everyone will definitely benefit from the changes.

The main downside is it's pretty expensive (if you have, say, 10 devs using it all day every day) compared to "free".

If you work on just a few projects, and/or you have very sophisticated systems across the board (like every site has an on-rails setup script with useful sanitized dev data, and secure SSO'd secrets management), I doubt it's worth it.

But in our case, a relatively junior dev being able to spin up a working dev version of a site they've never worked on in 5 minutes with no issues, so they can knock out a 3 hour change and maybe never work on it again, is a big money saver.

It's also meant that we can more easily standardize everyone's laptops without having to consider how well they work as bare metal dev machines (which has meant we can move everyone to fairly cheap macbook airs without people moaning about their tooling or storage size etc.)

I also like that access to a lot of stuff becomes directly mediated moment to moment by someone's github access (which for us also runs through our sso, cloudflare zt etc).

We're doing it in a slightly clunky way though - we use docker compose still, inside the codespace. I like this approach personally bc it feels like we're less locked in to the platform. For us it also made the initial migration easier. I think it also makes debugging the environment a bit easier because you don't need to keep rebuilding constantly on changes, you can just dcb dcup...

I have not used a full blown online environment. Except maybe VSCode remote using SSH. I repeatedly find anything that requires a network call somewhere in between a serious impediment disrupting the flow of development. Sometimes I find myself in slow laggy situations with ssh to the point I prefer Mobile Shell mosh. VSCode remote (or similar) via ssh obviously becomes painful.

Most cloud environments are also limited in terms of what you can do. e.g: issue sudo while running a process, attach to a process with a debugger.

Usually when these come development environment ready, it also hides away underlying details - i.e, I no longer know the command line etc to should I need to write infrastructure code/automation later on.

I guess there are domains where these are non-issues. But for a wide variety of my use-cases local development is going to be preferable, because by design there are limitations in the alternative.

I don't really see the appeal. We don't even use the same dev environments at work, some use vscode, others use pycharm or codeblocks or whatever. We have code locally, on github, on gitlab and in other places.

Also I can't really say that I've heard anyone outside of this thread who is excited about this at all. I see people here have different ideas but personally I've never heard of it from anyone I work with or know directly.

I got a cheap Hetzner Auction server for all the work needs https://www.hetzner.com/sb . I use VS Code remote to work there. It's easier and more convenient than Codespaces (and I think cheaper). Has a lot of benefits like instantly sharing a web server with the outside world, ability to run my servers and bots continuously, ability to work from different computers seamlessly. It also functions in many random ways (e.g. as my Anki backup server)

I rent server rack space at a datacenter where I have a beefy workstation to do all my work. I use VS Code Remote and SSH port forwarding. The workstation has fast 2TB NVMe and 64gb of ram, 16 cores and a RTX GPU. It's actually cheaper and faster than our production cloud server.

I tried Github Codespaces and thought it was cool but wasn't nearly as fast as my remote workstation.

We've started integrating Codespaces into our team's workflow. It's been a game-changer for onboarding new devs. No more "works on my machine" issues. The ability to jump into any project without the setup hassle is pretty sweet. We're still ironing out some kinks, but overall, I'm pretty bullish on it for professional use.

Frankly I dont get the appeal. And I've also used these in a really polished env (a company rhyming with schmookle) where decades of r&d had gone into building this. Where these are useful (though a pain to use) is if you have to work on a system whose components that cannot be built individually. Ie you need a production grade spanner, and env with all of the 15 microservice dependencies with their 15 dependencies each with their 15 dependencies each and so on.

At this point id question if I want to be this tiny piece of a tiny cog in a tiny gear among a billion gears in the huge clunky machine (comp and bottom layer of Maslow hierarchy aside).

We use Gitpod (https://gitpod.io/) for our eCommerce Magento development tasks across all of our projects at Develo (https://www.develodesign.co.uk).

This gives our support developers instant access to a fully configured development environment across all of our client sites, it really helps speed things up, previously there would be a min of 1-2hrs local setup for a new developer to work on a project, now it's 5 mins and guaranteed no problems getting going. So we can spread support developers across more projects and not worry about local setup. I put together a free starter repo if anyone wants to try that for Magento dev https://github.com/develodesign/magento-gitpod

Happy to chime in - Love the discussion ;-) Disclosure: I am the co-founder of Strong Network - a Swiss company. We are using and selling our own CDE solution.

My background is in cybersec and I worked at Snapchat after they acquired my previous (cybersec) startup - first time I saw the concept of CDEs, naturally I thought - can we combine productivity and security? This is what Ozrenko (my partner and ex Snap as well) and I decided to do.

Along with all CDE management functions, we designed infrastructure security mechanisms that are transparent to developers and that make their life easier (I and Oz are developers) - we realized that, we can expand the concept with a load of DevSecOps automation and eventually, we've hit very novel code security practices that we embedded in the environment (and filed patents on them).

Our security is mostly to keep developers chill while protecting the org (and reduce infrasec cost ;-) : protect all resource access credentials from leaking (phishing and malware), we provide data loss prevention (IDE, web apps), we detect secrets and prevent sprawling, we detect external code pasting in the code base, etc. All transparently and no hassle for the dev team - everybody gets free SSO to any resources!

Most importantly, we have hardened the platform at very complex organizations such as Broadcom, SwissRe, Niantic Labs and others with our self-deployed platform - you can imagine the difficulty of running efficiently across WAF, traffic proxies, VDIs and SASE. Oz is the man for that.

So in summary - we have today the most advanced CDE platform that provides both efficiency and security for all your resources and assets. We are a Swiss company working world-wide (greetings from Tokyo this week), so if you are motivated to join us (any function), please let me know!

Sadly, we have not chosen a codename for the platform yet.

At Coherence (withcoherence.com) we are building a slightly different twist on this where one configuration can drive different environments across the SDLC - Cloud IDE for dev, full-stack branch previews, CI/CD, staging/qa/UAT, production - with deployments in your own AWS/GCP account.

We generally see a ton of velocity increase in dev from teams that adopt the Cloud IDE alongside the rest, as exhibited by lots of comments. Internally, we dogfood them 100% and the team would never go back to the old "local-first" ways. So we are using them and love them. The key qualities we love are ephemerality, parallelism, and accessibility. But in general there is a lot of resistance for various reasons, as seen in many comments here.

We wrote up some of our POV in our docs here: https://docs.withcoherence.com/docs/explanations/remote-deve...

[I'm a cofounder of Coherence]

This is one of these things that I'm shocked there isn't more widepsread uptake on. It seems to win on some of the more important dimensions: ease of use/UX (if executed well), power of machines -> faster iteration time for many workflows, improved priacy. I am not familiar with pricing for many of these offerings and I suspect it probably is pretty expensive.

Even at megacorps where they have really good cloud dev environments, adoption is not universal. Many many people at my current employer have big under-desk workstations to do their day-to-day programming.

At Niantic we use Strong Network: https://strong.network/

It's a swiss based company that provide a secure environment based on container.

We like the many security features they offer, like proxying outgoing connections, organization wide controls, importing automatically source code ACLs and many possibilities for custom images. Onboarding new people is also very easy once we got our custom base images working.

We have a very good contact with Strong network and they are very responsive to our requests and comments.

Compared with other integrated Web IDEs, we feel that security was at the core of the design, which is not always the case, and this transpires in the way the product is structured.

Most of the CS classes at my university have moved on to an online Jupyter environment with VS Code preinstalled. It lets students spawn an environment with all the required software for their class preinstalled.

E.g. For Computer System it spawns an environment with GDB pre-installed, while for Intro to AI it has PyTorch/Python3 pre-installed

For Jetbrains users:

Step 1. Create an Oracle Cloud account Step 2. Create an Ampere 6 core, 32gb memory instance for like $5/mo Step 3. Use Jetbrains Gateway to run your IDE as a thin client, executing on that host.

You get a pretty darn beefy ARM64 VM instance from OCI for extremely cheap. You can get these in a region near you, with low latency. And Jetbrains Gateway works pretty great.

On the plus side, this is an entire VM, so if you've got containers, or whatever else you need to run, that all executes there too.

No because I want the entire development environment to run locally (and anywhere else) without WAN connectivity.

We use remote dev VMs with VS Code connected via SSH. It works a treat for a small team working on microservices. You can work from any machine while everyone has their own user account. Sharing code is a breeze. It's easy to test APIs in development (no http tunneling). Deploying to a local (on the VM) docker host for longer running services in test works well and it's super cheap to run.

Yes! But I work on CodeSandbox, so that creates some bias :). We've been working on our own CDE solution, though we've taken a different spin to improve speed and cost.

Our solution is based on Firecracker, which enables us to "pause" (& clone) a VM at any point in time and resume it later exactly where it left of, within 1.5s. This gives the benefit that you won't have to wait for your environment to spin up when you request one, or when you continue working on one after some inactivity.

However, there's another benefit to that: we can now "preload" development environments. Whenever someone opens a pull request (even from local), we create a VM for it in the background. We run the dev server/LSPs/everything you need, and then pause the VM. Now whenever you want to review that pull request, we resume that environment and you can instantly review the code or check the dev server/preview like a deployment preview.

It also reduces cost. We can pause the VM after 5 minutes of inactivity, and when you come back, we'll resume it so it won't feel like the environment was closed at all. In other solutions you either need to keep a server spinning in the background, or increase the "hibernation timeout" to make sure you don't have the cold boot.

It's kind of like your laptop, if you close it you don't expect it to shut down and boot the whole OS again when you open it. I've written more about how we do the pausing/cloning here (https://codesandbox.io/blog/how-we-clone-a-running-vm-in-2-s...) and here (https://codesandbox.io/blog/cloning-microvms-using-userfault...).

I'll repost here a comment I made on another HN post about cloud dev environments and why I will never be convinced to use them.

> I have never in my career seen a good implementation of cloud development. At every company I've ever worked for, "cloud development" is nothing but a Linux VM that gets provisioned for you in AWS, a file watcher that syncs your local files to the VM, and some extra CLI tools to run builds and tests on the VM. And every time I've used this, the overhead of verifying the syncing is up to date, the environment is consistent between my laptop and VM is the same, all this other mess...every time I end up just abandoning "cloud dev" and doing things on my laptop. God forbid you change a file in your cloud VM and forget to sync in the reverse direction. Not only is local development more reliable, but it's also faster (no remote network hop in the critical path of building things).

It is interesting that in the comments on this thread I’m not seeing any mention of nix, which is arguably overlapping the topic at hand with the Venn diagram of “spinning up dev environments”.

I used Cloud9 for about nine months before Amazon acquired the company.

I loved it-- I loved having separate environments per-project. I enjoyed the collaborative features as well (send a link to look at code or preview something, etc). I see a lot of potential with them and I would love for them to be more mainstream.

After Amazon acquired the company I cancelled my subscription (I was paying annually.. I think it was $190??). I knew Amazon was going to murder the service, require an AWS login and who knows what.

I have tried others since then like code spaces and some open source/self hostable solutions (I have even tried the old self-hostable Cloud9 code).

Ultimately, I gave up on it... why? I didn't like the idea of self hosting (more attack surface area, etc). I didn't like any companies offering the service.

I use codespaces and replit quite a lot. It's just very easy to work from anywhere and I spend quite a lot of time in VR (because it's convenient for me to work with large screens vs actually having large screens; also better battery life than my laptop).

The trend towards cloud dev environments will continue for a while. Some people will spend years working full time developing support for these. They'll make assumptions about network connectivity and resource cost while building layers and layers of abstraction to get the whole thing to work. Bringing up a dev environment will be mystified and no single person will know how to do it.

Then someone will realise "hold on, can't my own computer run this stuff?", get rid of all the cloud layers and run the environment directly on their laptop.

They'll write a blog post about it and people will be amazed that it's possible.

And the cycle will be complete.

GitHub moved to codespaces for dev 2 years ago

https://github.blog/2021-08-11-githubs-engineering-team-move...

We ise Coder at our lab for machine learning simulations. We have a self hosted Coder deployment and use docker to proviosn workspaces on our GPU servers. Each lab member can spin up a fully working, dev environment in less than a minute and they don't ever have to think about installing it configuring the. Correct CUDA version, GPU drivers etc.

We persist home directory of a user across all their workspaces and also mount a common data directory to all so that we have access to ore downloaded datasets.

I am sorta doing this, locally. I have a handful of servers in my basement that I use vscode+remote-ssh to work with. The benefit is that I can jump from my desktop to my laptop without any fuss. I can leave long-running scripts online for like an experimental batch job and attach to that from any machine, even when I am not home thanks to wireguard/tailscale. It is very nice knowing my dev env is always there in the state I last left it. This also gives the nice benefit of being able to choose your developer env (windows or mac) while running your dev/code/system on a linux system for example. It also gets you around architecture issues, like if your laptop is arm-based and your app needs x86.

I was initially kinda opposed to this and preferred "bare metal development" on my local rig. But the performance is actually pretty incredible for remote development with vscode such that I don't really notice things are running on different hardware.

We recently had some new members join the team and I decided to spin up some dedicated EC2 instances for them to use for this exact purpose. They aren't being used yet, but as our stack becomes more sophisticated I think workloads will transition there. It's done with a custom terraform module that also provisions other assets needed for each dev (regardless of local or remote dev) like an S3 bucket, some dynamo tables, IAM roles, etc. Being able to onboard a new dev with a handful of lines added to a mapping is pretty awesome.

tl;dr I would absolutely consider remote dev spaces.

None of those, but on my last contract, the client used D.O. + Docker envs for "local" dev. Personally, I loved it. I didn't have about to worry about getting a project to work on my on-desk hardware. I simply opened VSC, VSC+SSH'ed in, and went to work. It simplified collaboration, etc.

By far, what I appreciated the most was I didn't have unnecessary data on my local hardware. No customer data. No order data. Nuttin'.

I thought CDEs were a pretty cool idea years ago until I discovered Nix and specifically "nix shells".

Call me old school but if I can run my tooling locally I typically prefer that in most cases, and Nix does a stellar job of tracking everything deterministically, so sharing amongst the team works great too.

So much so I think replit actually uses it under the hood for some of their environments iirc.

We do a mix:

* quick PR tweaks on someone else's branch => github code editor

* data science & customer success work: jupyter notebooks (GPU) & google colab (CPU)

Based on those experiences, and local dev experiences, we invest in a mix of native + containerized + ci/cd staging server dev experience... and not experimenting with cloud IDEs.

As an Android develop this greatly interests me. In fact this was one of the reasons I had to buy a more powerful laptop than I wanted to and it almost cost me double my target laptop otherwise. Because Android development is such a resource hog.

Are there useful cloud dev env setups for Android? The way Google has made sure Android dev remains locked in to Android Studio i.e IntelliJ Idea and also to the Great Gradle and what not I assume it’d have to come from IntelliJ - https://www.jetbrains.com/remote-development/.

Has anyone successfully tried this for Android remote dev? I suspect even if it’s feasible with lots of fragile moving parts the resource hungry setup will surely make it very costly for having a personal setup in the cloud.

I only lightly use the cloud hosted environments but regularly use dev containers now to ensure that complex development environment are only configured once and shared amongst a team. It ensures no more ' works on my machine issues ' plus means both development and production are extremely stable

Yeh. We use DevPod to work in cloud dev environments in our AWS cloud. I hate it. DevPod brings its own SSH implementation that injects itself into your server and munges CRLF, making ssh sessions to your workspace fraught with difficulty except for basic command line applications. The only terminal that seems to work is the one built in to Visual Studio Code. Maybe Microsoft Windows Terminal also works, I dunno.

If you have editor attachments and want to work this way, suck it up and learn your VS Code. That's what all the tooling supports first class. Second class is JetBrains. Vim and Emacs aren't even considered. I'd say just run them from inside the container, but then you run into things like custom SSH that munges CRLF. When you look at who actually authored the devcontainer standard, it makes sense.

Codespaces user here (I set it up for the teams), for about the last 1.5 years in a large corp setting with teams using it.

My experience with is it has been wonderful for getting started and immediatly becoming productive with very complex systems. Most of those systems have 1 (or very few) experts who need to help everyone else with their setups. When problems arise, and they often do, they've become the bottleneck and Codespaces removes that. Those experts can focus on keeping just that up globally versus locally for each individual.

Outside of that scenario, complex systems, I've experienced it to be overkill. The negatives that come along with using such systems haven't outweight the benefits.

After our experience of running Codeanywhere for more than a decade, the whole market and technology finally started to converge to the moment when those solutions started to be meaningfully useful in work environments.

Today, with Daytona we are trying to solve just exactly this challange. Daytona is the enterprise-grade GitHub Codespaces alternative for managing self-hosted, secure and standardized development environments.

The unique value of Daytona is that you can self-host it on your own infrastructure and benefit from high-density workspaces which offer efficient resource utilization while ensuring a great developer experience.

Disclosure: Obviously, I work for Daytona, and was working for Codeanywhere. :)

We at Broadcom use "https://strong.network/" which gave lot of flexibiltiy and platform/resource control as well boost to productivity for our development community. A part from data loss prevention (IDE, web apps) and security that this platform provides, it helped us to Host , scale , delegate within our organization which is also a cost effective solution that other current solutions availble are lacking .

We at LinkedIn have been using CDE's (we call them rdev) for quite a while. We wrote about them in our engineering blog:

https://engineering.linkedin.com/blog/2021/building-in-the-c...

I'm happy to answer questions but others have already posted many of the benefits. As far as I know, local containers on macOS still have performance issues so we mostly use them in the cloud.

We’ve been using vscode containers for our complex repos since getting deterministic Python environments are almost impossible with current tooling.

For our node/js repos, yarn does a great job at keeping things simple, deterministic and fast. So even if we have containers, devs use the direct method for faster devloop.

For bigger companies with much more complexity, remote devboxes make a ton of sense. You want to manage farms, not individual flower pots.

Nice thing about containers is that you can run it locally without internet.

Containers + vpn solves a lot of pain.

https://bunnyshell.com and k8s -- seems like a good way to get going quickly with new projects --

Besides using Codespaces for inspecting code, I’ve used it for running some applicants’ submissions a few months back.

One of the submissions was built in Java and didn’t use Docker (I guess the person had an aversion to it). I didn’t want to bother installing Java on my machine, so Codespaces seemed like a good idea. It took less time to get it working than it would’ve to find the download link on Oracle’s website.

I’ve also used it to write a few lines of code on my iPad, but this was far from ideal.

I've used Github codespaces at work when I wanna make small modification to an open source repo and don't wanna go through the entire process of cloning, building things, etc. It's prety useful.

We have our own custom built cloud dev envs where I work and I def see the value. I don't need to worry about a conflicting version of a dependency that I have installed locally for some prototyping affecting my day-day productivity.

My computing environment mostly consists of a browser and tmux, with vim for editing. A few months ago I wanted to try Github Copilot, so I signed up for the trial thinking I could use it in Codespaces. Eventually I gave up and installed VSCode locally. Now I use it a little, mostly for exploratory work, but less than I would if it were in my browser.

Is there any CDE with good Copilot (or equivalent) integration available today?

I don't really trust the whole Node Package Manager ecosystem and will happily use a prophylactic like Codesandbox on my work computer where possible.

Also I have to upskill some colleagues and what better way to do that than share a demo in Codesandbox that they can fork and play with, rather than an email with 20 step instructions on installing node (on Windows)

For actual development I can't work with a thin client, it's too slow.

We now have an in-house cloud dev environment at Airbnb (note: my opinions are my own and not those of my employer) and it was a huge improvement over what we had in the past.

Spinup time is fast, it's easy to use VSCode remotely, and it's easy to have multiple environments for different types of projects (Python, Java, Go, etc.).

Neovim + LSP's also works perfectly if you prefer that over VSCode (via ssh)

I use private replit(s) sometimes to work on small snippets of code. Then I use my code snippet as a reference when working on our actual codebase.

Full disclosure: I'm a Gitpod Community Hero (i.e. volunteer ambassador)

Personally I used Gitpod at work every day (Nx + React on a fairly complex stack) for 2 years and I loved it.

Always fresh, always working. I don't use it (at work) anymore because I moved to another company and some of us are in Australia / New Zealand where latency becomes a issue (so far).

Sorta, I have a beefy PC at home and I use Parsec to just stream my screens to my laptop if I'm at the office or whatever.

Not quite the same since it's not really containerized, but I set up the project once and then I'm good to go from there

It's nice cause I detest Apple/MacOS and this lets me avoid it completely since I'm just interacting with a Debian machine

Probably not what you mean by "at work" but as a non-CS STEM academic that needs to help my colleagues get dev environments so we can collaborate on research software, devcontainers are a game changer. I work a lot with folks that are scared of the command line, but I can get them productive in their web browser with much less friction these days.

I have a somewhat remote setup - I use a server which sits in my basement. It is helpful since running some things is just easier on a x86 Linux machine vs a M2 MacBook!

Vs code works great but I would really prefer to find a way to get neovim working with less lag. Mosh support is improving but still isn't fast enough not to be annoying!

My dev environment is emacs + gcc + gdb + and sometimes . I have an EC2 instance I ssh into and as long as my network connectivity is decent it's not a bad experience.

But that's probably not what you're talking about.

Not me, but I have been looking for a self-hosted CDE; anyone have experience with Eclipse Che they would share?

I've used Replit for love coding interviews when we are talking with candidates. From what I have seen I don't think I would choose to switch to it for a large project. However, it is nice for quick examples of a way for someone to write small chunks of code with no setup.

I used Cider while at Google, and setup Google Codespaces at the startup I'm working at now.

Some notes:

- Codespaces uses the devcontainer spec, so folks can use our setup offline if they want

- I get far fewer questions about how to do XYZ, and when I do get questions, I can almost always reproduce them, which is a breath of fresh air

- We do pay a fair chunk to use high CPU/memory machines, this is worth it for us. I have a very lightweight laptop that I use

- Some of our developers like having multiple separate codespaces at a time as a way to separate out different projects. I just use branches, but some folks like the codespace workflow.

- I can run vulnerability scans over our dev environment which is nice

- When I onboard devs, I can get them to the point of running our full application suite in a 15 minute meeting

- I don't have to deal with m1 vs not-m1 issues that were popping up all the time before we made the switch

- Having a linux base is nice, as that's what we use in production. We deal with some annoying dependencies and not having to install them on Mac anymore is nice

- It's seamless changing between my laptop and desktop that I work from. All the code is instantly on the other when I switch, even if I haven't pushed up to git

- Chrome + Notion + Slack + our task tracker app + etc. take up a lot of memory now adays. Even with 32gb machines, folks often would run out of memory trying to run our app. On a codespace, all of the memory is dedicated to just the app.

- With prebuilds, when a developer opens a codespace, we already have all of our python, node, go, etc. dependencies preinstalled (also things like awscli, terraform, pre-commit, VsCode extensions, docker). They just run `aws sso login` and then `start --serve` and things work.

- I live in an RV, and sometimes don't have great internet, but my Codespace is on a remote machine that does always have fast internet. Even being an internet-based service, this works great for me.

The biggest cons:

- Some of our devs were really passionate that they preferred other IDEs than VsCode. Some other IDEs do now have support, but they aren't as supported as VsCode yet

- Codespaces have downtime occasionally (as did Cider at Google). Most folks just use a local copy/devcontainer of the app or do other things when this happens, but some folks choose to always use devcontainers/local copies because this annoys them so much. At Google, we just posted memes when this happened and went home.

- Codespaces become inactive after a controllable amount of time has passed. Some folks don't like the 40 seconds to reactivate a codespace after being inactive for more than 30 minutes, so they either write scripts to keep their codespaces alive or just don't use codespaces at all.

Overall:

- most of our newer employees exclusively use codespaces.

- A few of our older employees who developed locally for years have chosen to continue developing locally, and will just hop into a codespace to run a quick terraform command or something if their local version gives errors.

- The number of questions we deal with regarding issues on a single users' machine have gone down dramatically, and tbh most of the questions come from folks who use the local still

- We do pay a pretty penny for this, but it's a small fraction of our overall cloud spend or costs per employee

I am a big fan of strong.network, they have convinced some of the best tech people I know with their offering and some market leaders in reinsurance, semi-conductors as well as other industries across the US, Switzerland and Asia are already clients

There are a few gotchas, but I've introduced them at both Vanta and Q Bio and have been thrilled with the productivity increase at both places. As long as you stay on top of keeping prebuilds green, you know that everything just works for all of your engineers.

My previous employer used them to test client integrations of our hosted services. They were nice to send a url for collaborative debugging rather than telling someone to go spin up a copy of the SDK and pasting them a block of json to configure it with.

I've been doing this personally and also pushing for adopting this at work. We are currently moving to monorepo though so we will probably look into this better after we're done with that.

doesn't quite fit the definition but at my work we use Vertex Workbench quite extensively. the rest of the organization is still with archaic IT practices, so it is quite liberating that we have full control (within reason) of our development environment when everything is set up.

its workflow is still quite at its infancy though. but the SaaS route has allowed teams new to adopting to best practices still benefit from them, while they move towards adopting them.

Do things like Wix, Weebly, Wordpress count as CDEs?

Replit to build very quick prototypes of some script and see what it would console log.

GitHub Codespaces for quick stuff, I prefer my IDE.

We're not, and I'm very glad for it. I am the opposite of excited about the idea of CDEs.

I use stuff like replit, online sandboxes, jsfiddle, just to execute snippets of code.

I'm aware of IDX though

I use Codespaces daily at work. Full disclosure, I work for GitHub. I like them pretty well.

I have used the GitLab cloud IDE at work for quick things. Not so much as a primary IDE.

hmmm why these sound like "connect via (video)terminal to $$somewhere" from the ancient times? Except the terminal is not a dedicated vt100 or Tektronix but your laptop..

I have a Macbook Air and vscode-remote over ssh to do anything.

Are these things charged per usage? Feels strange to me.

Director of Product for Codespaces here... AMA

I considered it but the cost seemed pretty steep - up to ~$30/day/dev for codespaces. I didn't think local development was close to broken enough to justify it.

bit biased, but we use coder (I work at coder)

"Based on my knowledge and experience, I think that the Strong Network solution is the most complete and robust approach for the enterprise"

"Based on my knowledge and experience, I think that the solution from Strong Network is the most complete and robust approach for the enterprise "