Generative AI like ChatGPT, GPT-4, Sage, Dragonfly, Neema, and Claude can accelerate DevOps and GitOps processes

Generative AI, like ChatGPT, is Helping Automate All the Things

Generative AI seems to be everywhere these days. ChatGPT, the current generative AI poster child in the media at large is a product based on the Generative Pre-trained Transformer (GPT) model. There are other chatbot-style generative AIs in play as well, Claude, Neema, Sage to name a few. In the developer community, maybe it’s a little bit more the GitHub Copilot project. In any case, these sorts of generative AI large language models, the LLMs like ChatGPT and GPT 3 and 4, now are effectively the forerunners of this current space. As has been pointed out in numerous other locations, but is worth repeating, ChatGPT is not the only language model that exists. And in fact, tuning a language model is a whole other topic that we need to get into another time. But the thing that I’ve noticed is that a lot of people are saying, oh, chat GPT, this kind of automated AI or super stats kind of systems model is going to completely change our developer paradigm. It’s gonna take our jobs. We’re not gonna have to do any of this. We can just do all of this through these AI tools. Though we all know that’s not the reality (You do know this, right?), it is certainly a game-changer. Every one of my colleagues that is in the development space has told me how much more freeing this is to effectively have a baseline, sort of a default system built out, that really helps them work through the process of what they’re trying to accomplish with their code rather than the underlying code itself.

Now, understanding your code is still really important. I’ve done a number of sessions now trying to look at how to leverage something like ChatGPT and its question-and-answer style interface. To build out infrastructure-as-code support for an application or even to build an application. These things do work, but they are by no means perfect. Be prepared for a constant fine-tuning process that goes on as you’re using something like a ChatGPT tool to enhance your code. The GitHub Copilot tool is even more attuned to this kind of process – where you’re effectively asking it for bug fix help, for process definition. (e.g. “How do I write a class definition in Golang for talking between an API and a web frontend.” or something like that.) You’re asking questions of that nature, but you still have to understand the architecture, the goals of your project, and the strategy. This is still coming from you, the individual developer, not the mysterious inner workings of a generative AI.

The other thing that I’ve seen is that, oh, this is going to change our jobs because we’re no longer important in this process. Well, I would say our jobs are very well in tune with leveraging these tools because these are all integrative things. Generative AIs are really augmentative tools for our development and operations processes. It is quite freeing to be able to say, you know, how do I accomplish a task and get something that is 90 percent accurate right off the bat? It certainly beats having to go through and pour through pages of docs for hours to try to figure out how something fits together.

Now, once I have that 90% accurate document, I can continue to ask ChatGPT or that style of interface to help me further refine it and get rid of deprecation errors and get rid of warnings and errors in the process itself. But it actually helps if I understand what the heck that language is trying to do and what the format of the language is because it means that I can help fine-tune the result. You get that augmentative function without having to give up all control of what’s going on.

Now, the other part of this is that now I’ve created some documented or rather usually undocumented code, I can use these tools to say, help me explain what this code does. So then I have a better understanding of the individual components and how they’re fitting together. And if somebody else needs to then leverage that code (which is really common, right?), we don’t want to leave our peers without any knowledge of what we’re trying to accomplish. At least if we’re part of a community, we don’t want to do this. So being able to document the code is really important and being able to do it quickly with a generative AI is a huge time saver.

So what does this really leave us with? Leaves us with a set of tools that are augmentative in nature and really can help accelerate processes. Going from nothing to deploying a website on AWS with S3 as your website manager is actually pretty easy. It can be done within a few minutes assuming that all the pieces are in alignment.

I tried this just the other day and, for example, you have to remember to tell it that you want it publicly accessible and you have to remember to tell the system that you want it to include an error page for paths that don’t exist. There are a bunch of pieces of the puzzle that are not just automatically given to you by something like a ChatGPT-like interface. But with an understanding of the system, with some of the basics, you can help fine-tune the environment and you feed errors back into the system too. And it can actually try to, sometimes it gets a little cyclical, but you can try to resolve those errors.

The key here is that the process is still just as important as it was before. We suddenly have this augmentative AI service available to support the process that is the DevOps or the developer-automated cloud-centric development process. While DevOps is the principle tool that we talk about in this process context, I would say that GitOps maybe is a little bit closer to what we’re really talking about. A process that ensures everything is automated: automating build, automating test, automating production release. Once we get to that true end-to-end automation, then yes, ChatGPT and Copilot and all these tools can actually help us. They can give us boilerplate, GitLab CI or GitHub actions, to take care of things like “How do I build a container on commit into the master branch?” It can tell you the processes, the things that you have to set up in the UI, and the code that you would need to add for your actions or for your CI commands. All of that can be generated from the language model as it exists.

Now, I’ve seen some areas where it would be really nice to be able to enhance that language model using my code structures, my default libraries, and my default models for things. By default, the ChatGPT environment doesn’t have any of that information because it doesn’t know anything about the specifics of your environment. Often we don’t want to give the OpenAI community our code specifically, we want it to help augment our code, understand our code, and leverage that. There are some issues, I think, with the GitHub code base that people are concerned about given that, apparently, some private code was also consumed by the AI engine in building out its codecs of weights and processes for how to build application code.

So it’s by no means a perfect solution, but if we look at it from the perspective of what can we do, how can we leverage the AI engine to really give us the best of all worlds? If it can help accelerate my development process, this is really where the cloud comes into play or more fundamentally the automation of IT and the automation of our development processes. This possibility is really the future of accelerated development processes. Somewhat like no code or low code types environments. These are effectively automating a bunch of the normal boilerplate tasks away from us.

But we still have to think about the process of our code. We still have to understand how the different pieces are interacting. And again, this is where these AI services can really help because they can help us understand the code that we wrote. Maybe it’s things that we wrote months ago and that we’ve forgotten what our architecture was, what our flow was as we were building it. Or maybe it sort of grew by accretion, which is the common way that applications are developed. Along the way we sort of lost track of which piece did what where, and how was this entire system architected. Again, the documentation aspect of “Read this chunk of code and give me some idea of what this piece is trying to accomplish for me” is really important.

That leads me to a couple of key things that we can do. Number one, we can actually define what our processes should be relative to these tools. Are we going to spend the time trying to get ChatGPT to refine our code hour by hour, minute by minute as we continue to ask it refining questions? The process will sometimes generate cyclical loops. You say, “Hey, this is broken or this is deprecated.” It gives you new code that doesn’t work. And when you say that code doesn’t work, it comes back and gives you the original deprecated code back again. There are loops like that that you have to be aware of. You have to see what’s going on. Just using these tools does not answer all the questions. You still have to apply a little bit of mental math to the process.

Also, it might be that it’s better for your organization as a whole to say, look, we can absolutely use these tools to help us build some boilerplate concepts. I need to build a web front end with a couple of tables and a set of inputs that I can define. I can get a boilerplate document for that written in seconds rather than in the hours it might take me to structure the code manually. That’s fantastic. Again, that’s effectively what the low code platforms are trying to help us with is that same kind of, let me help you with the things that are repetitive and constant and consistent so we can map that into our process.

The other thing that we have to consider is as we start building this… If we don’t have an automated test environment, if we don’t have an automated build environment, if we don’t have an automated Git check-in environment, something that can further enhance our Git check-ins because it’s very common, especially, there’s sort of two ends of this, but there’s the Git check-in, which is the, I checked in one line of code. Obvious what that line of code does. There’s no point in me writing a description of it, but it has no context. And that means that check-in is absolutely useless. I can’t revert back to that point in the check-in process, because I have no clue what that code changed and what it improved in the system or anything like that. So being able to incorporate the AI engine in helping to describe what a check-in is doing, sometimes it’s going to basically say, yes, this adds a variable. And that’s all it knows because even in context, that’s really all it can tell is going on. But it can also start to say, yes, you’ve added these three functions. They’re providing this kind of functionality within the platform. And now your check-in is much more useful.

So even adding automation to those areas where you’re using the large language models or this style of interactive AI is, I think, a really powerful way to further enhance this capability. And the last thing is to automate everything. Again, this does not obviate the need to automate all of the processes that you have, at least as far as you possibly can. Even automate the integration of these generative tools. This is where I think the GitHub co-pilot type interaction is really going to be powerful because it does automate the lookup of a function call. It does automate an error-checking process. You can still tie all of this into the other normal processes that you have. Asking ChatGPT or asking the AI systems if there are any security concerns with the code as it’s written is actually really informative at times. Sometimes there’s nothing, it doesn’t see anything, but adding that as a further check, hey, here’s a report, basically a code scan, but from a different perspective on the applicability of your tools to the modern internet. These are all great ways to leverage this technology.

And as we’ve sort of been describing here, this does not change the fact that you do need to understand the language that you’re working in. Yes, you can get away with a lot without understanding a single bit of how Python works or Golang works or heck even Rust. But in the end, somebody still needs to understand the code. Somebody still needs to understand what’s being created. So it doesn’t remove the need to have that concept. But seeing how effectively the rest of the Internet is doing the types of things that we’re trying to do can be incredibly useful and incredibly helpful. So don’t be scared of these tools. Understand that using them is not a free ride. I think that’s really maybe the key here is ChatGPT and Copilot are really our augmentative tools. They are not a replacement for a smart developer or a smart operator in an environment. This has been Robert Starmer bringing you another episode of Five Minutes of Cloud.