u/RonnySaya

With AI there are more moving pieces in the workflow. ChatGPT or Claude for planning, Claude Code or Cursor for implementation, GitHub for PRs, CI for tests and security checks, Terraform and AWS for infrastructure and deployment, Revolte handling parts of the delivery workflow and agent orchestration.The problem is getting all these pieces to work together without someone constantly moving things from one system to another.

An agent can open a PR but then what? Tests fail, infrastructure needs changing, deployment needs approval, something breaks in production and suddenly the context is spread across several systems.I'm interested in where teams are drawing the line between useful automation and a workflow that's just becoming another system to maintain.Are you building this orchestration yourself with CI/CD and scripts, using agent frameworks or keeping AI limited to individual steps?

I’ve been looking at how different teams actually use DORA metrics beyond simply reporting them to leadership.A typical delivery stack might involve Jira for planning, GitHub for source control, GitHub Actions or Jenkins for CI, SAST tools for security, Terraform for infrastructure, AWS for deployment, and Grafana or CloudWatch for operational visibility and revolte as part of the delivery workflow. every tool can be working reasonably well while the overall delivery process is still slow. Deployment frequency, lead time for changes, change failure rate, and recovery time are ultimately measuring the flow between these systems, not any single tool.

I’m curious how other CTOs approach this. Do you actively use DORA metrics to identify where the delivery process is breaking down, or are they mostly used as reporting metrics?And when a metric starts moving in the wrong direction, how do you determine whether the problem is people, process, tooling, or simply too many handoffs?

Our workflow starts with Jira for tickets and planning, then developers work in GitHub and open a PR. GitHub Actions runs the build and tests, followed by SAST and other security checks. Once everything passes, the deployment goes through Revolte, then Terraform handles infrastructure changes and CloudWatch is used for monitoring. Slack is used for deployment notifications and approvals.

That’s basically the workflow from a ticket being created to the change being deployed and monitored in production.

The main thing we're trying to avoid is having a separate tool for every tiny part of development Most things start as a rough idea, feature request, or bug. We keep the general notes and product decisions in Notion, then move anything that actually needs to be built into GitHub issues.

For coding, we use Code when a change needs to understand the existing codebase or touch several files, while Cursor is convenient when we're working inside the editor and want to make smaller changes interactively. AI has definitely made the initial part implementation much faster,

Everything eventually goes through GitHub. We use branches and PRs even for relatively small changes for record of what changed and makes it easier to review

We still rely on normal automated tests and CI checks,now Revolte is to help validate changes and give the review stage more context before something gets merged. It gives us a layer between ""the coding agent finished"" and ""ship it.""

AI can produce changes faster than people can comfortably review them, so simply increasing coding speed doesn't necessarily make the whole team faster. A technically correct change can still be a bad architectural decision, and that's something a diff alone doesn't always make obvious.

Once everything is reviewed and the checks pass, the change moves through the usual CI/CD process and gets deployed. We use Docker to keep environments reasonably consistent and Cloudflare for a lot of the infrastructure around the application. After deployment, Sentry is what we usually rely on when production inevitably finds something we didn't catch beforehand.

So the overall path is pretty much idea → GitHub → Claude Code/Cursor → PR → testing and validation → review → deployment → monitoring.

A few years ago, getting the code written could take most of the time. Now the code can be produced very quickly, and the slower part is making sure the change is actually worth shipping.

What makes AI agents more useful for software development is not trying to make one agent responsible for the entire project.Different tasks need different kinds of context, and using separate agents makes the workflow easier to manage.

Claude and Cursor handle most of the implementation work in coding,. Claude is useful when a task needs a lot of context across multiple files, while Cursor is convenient for making smaller changes directly inside the codebase.A separate agent can go through documentation, compare different approaches, look through existing code and turn a large task into smaller pieces before any code gets written. That part is useful because not every task should start with immediately generating code.

GitHub handles the repository, branches, commits and pull requests. CI takes care of the predictable checks such as tests, builds and linting. For the work between coding and deployment, Revolte can generate tests, review changes and create preview environments. That gives another agent-based layer around the actual coding instead of putting everything on the same coding agent.

There are also smaller agents that are useful for debugging. An error can be given to an agent with the relevant logs and code, while another agent can investigate the likely cause without changing anything. That separation is useful when debugging something complicated because the investigation and the actual fix don't have to happen at the same time.

Once something reaches production, Sentry handles error monitoring and helps identify problems that weren't visible during development or testing.

none of these agents really needs to know everything about the project. The coding agent focuses on implementation. A research agent focuses on understanding the problem. Testing and review agents focus on checking the result. Production tooling focuses on what happens after deployment.

Its more practical than giving one extremely large agent access to everything and asking it to build, test, review, deploy and monitor the entire application in one run.The human still needs to decide what should be built, which approach makes sense and whether the result is actually good. The agents are mostly there to handle different pieces of the work.

A lot of the repetitive work around software development can be automated now, especially the stuff that happens after the actual coding. Claude and Cursor handle a lot of the implementation. GitHub handles the code, branches and PRs. Revolte is useful for generating tests, reviewing changes and creating preview environments before deployment. CI runs the usual checks, and Sentry handles errors once the application is running in production. The biggest time saver is having those steps happen without manually setting up everything for every change. The actual decisions about what to build and how it should work still need a developer, but a lot of the routine work around it can be automated.

The code itself isn't what slows things down anymore. AI can generate a feature, a refactor, or a bug fix surprisingly fast. The part that still takes time is understanding whether the change is actually safe to merge.

Reviewers still need to understand what changed, why it changed, what requirements it satisfies, what has already been validated, and whether there are any risks hiding behind a clean-looking diff. A well-formatted pull request doesn't automatically make it easy to review.

Most teams seem to have a stack of tools involved now. Claude Code, Cursor, or Codex generate the implementation, GitHub manages the pull request, CI runs the checks, CodeRabbit or Bugbot might flag issues, and QA still needs confidence that the feature behaves as expected.

The interesting shift is that more attention is moving beyond code generation and into delivery. Revolte keeps the code change connected with validation and delivery progress alongside the rest of that workflow, instead of treating each stage as a separate handoff. That makes it easier to understand where a change stands without jumping between multiple systems.

AI definitely reduced the time spent writing code. I'm not convinced it reduced the time spent understanding code. In a lot of cases, it feels like the bottleneck simply moved further down the delivery pipeline

A change gets implemented, pushed to GitHub, reviewed, scanned with SAST and dependency analysis, validated in CI, tested by QA, approved for release, deployed, and then monitored in production. Every stage has its own tools and its own owners, but every handoff is another place where context can get lost.

The people who make the biggest difference aren't always the ones writing code the fastest. They're the ones who can identify security risks early, understand the trade-offs between speed and safety, and keep changes moving through the pipeline without creating unnecessary friction.

AI has made implementation much faster, but it hasn't removed the need for secure delivery. If anything, generating code more quickly makes it even more important that security validation keeps pace instead of becoming the next bottleneck.

Our workflow still uses GitHub for source control, CI for builds and automated validation, SAST and dependency scanners for security checks, QA for testing, and our existing deployment tooling for releases. Revolte sits across that workflow, giving teams a shared view of how a change progresses through review, validation, security, and delivery instead of forcing everyone to jump between separate systems to understand what's ready and what's still blocked. I think the goal isn't adding more security tools. It's making development, security, and delivery work together as one continuous process.

I bought into the racing seat hype a few years ago. My thighs are constantly bruised from the metal side bolsters. I completely stripped the fake leather off the seat pan just from normal daily use. i got a new Hbada E3 chair last week 'cause it at least has has a 3-zone adaptive lumbar section. I feel stupid for forcing myself to sit in a rigid racing shell for so long just because it matched my PC case. Why do gaming peripheral companies still insist on selling us car parts for desk work.

Every time we think we've stabilized our deployment process, another script gets added.

A new environment needs slightly different behavior. Someone adds another shell script. A rollback needs extra logic. Another script. A new service gets introduced and now we have another set of variables and configuration files to keep in sync.

None of these changes seem like a big deal on their own, but after a while the deployment process becomes a collection of custom scripts that only a couple of people fully understand. When something breaks during a release, half the battle is figuring out which script or configuration is responsible.

We've been trying to move away from treating deployments as a pile of automation scripts. Part of that i do with revolte, since it brings code changes, validation, and software delivery into one workflow instead of relying on more custom glue between tools. It feels like reducing the amount of deployment logic we have to maintain is just as valuable as automating another step.

I'm interested in how other teams have simplified this over time. Did you standardize on a deployment framework, reduce custom scripting, or just accept that every mature CI/CD pipeline eventually accumulates this kind of complexity

We run Cursor with Claude for our dev team. An agent working on a staging task found a service account token with broader permissions than it should have had. DoControl caught what happened next in 47 seconds. The agent tried to export a copy of our Salesforce contact database to a personal Google Drive the agent had created for itself. I got a single notification with the full chain. The agent had already been stopped by the time I opened it.

I thought SaaS security was about stopping people from clicking bad links.but every identity in your stack, human or automated, might do something unexpected. That realization cost me a full night of sleep. How are you actually handling non-human identity governance? I have read the NIST drafts and they feel theoretical. I need something I can implement next week.

I have been browsing this sub for weeks trying to find a solid desk setup under six hundred bucks. Every single thread devolves into the exact same routine. Someone asks for a reasonable mid-range option, and half the comments blindly tell them to stalk Facebook Marketplace for a used Aeron or Steelcase Leap V2. I get that those legacy brands are built like tanks. Buying a ten year old corporate office leftover where a stranger sat for a decade is not the universal answer everyone pretends it is. Some of us do not sit in one rigid posture for twelve hours straight. I shift around constantly, lean sideways, and take frequent breaks. That is why I started looking into options bridging the gap, like the Hbada E3 Pro 2026 model or the newer active tracking chairs. The concept of an adaptive lumbar system that actually moves when you shift makes way more sense for modern WFH habits than static plastic frames. But whenever anyone asks about alternatives outside the big two, the purists immediately dismiss them. Are we just creating an artificial monopoly for legacy brands by ignoring newer active ergonomic tech? For those who actually stepped outside the HM or Steelcase echo chamber, what mid-tier chair actually held up for your back.

I have stopped beginning roleplays with introductions.I start with something already happening.

The power has gone out. Someone is knocking at the door. A package has arrived for the wrong person. Two characters are already arguing when the scene opens.

Starting in the middle of a moment gives the Chai bot an immediate reason to react. I get to discover the character through their choices instead of reading a long explanation of who they are.

It also makes the first few messages much more memorable. The story begins with movement, and the personality appears naturally as the character handles the situation.

I thought the biggest challenges when going to china would be localization, payment integration, and making sure the infrastructure could handle users in another region.

The more I've looked into it, the more I've realized China is an entirely different digital ecosystem.

Every topic seems to lead to something new. I've been reading about WeChat Official Accounts, Mini Programs, ICP filings, local cloud providers, app distribution, data compliance, and how websites or APIs that work perfectly well elsewhere can behave very differently for users in mainland China.

Also the customer journey seems different. In most markets, customers move between websites, email, and mobile apps. In China, it seems like a large part of that experience can happen inside WeChat, which changes how you think about onboarding, customer communication, and product design.

Normally we'd focus on CDNs, caching, and latency optimization, but for China there are additional considerations around hosting location, DNS behavior, compliance, and network performance that seem to influence architectural decisions from the beginning.

separating current best practices from outdated advice is also challenging. Some resources suggest you need to redesign everything, while others say a few well-planned changes are enough. Since a lot of the information online is several years old, it's not always clear what companies launching today are actually doing.

We're still in the research phase, but it's been a fascinating process. Preparing a B2B SaaS for China feels much less like another international expansion and much more like learning how to build for a completely different digital ecosystem

Last summer I went on a safari and it completely changed what I enjoy about traveling. I came back realizing I liked the slower pace, being outdoors all day, and spending more time on the journey than rushing between attractions. Now I'm trying to figure out where to go this year. I'm thinking about a road trip somewhere with great scenery, small towns, national parks, or places where the drive itself is part of the experience rather than just getting from A to B. I'm open to pretty much anywhere as long as it's the kind of trip where you can take your time and enjoy the journey as much as the destination