In early December the nice people at Packt got in touch again to ask if I would like to review a new book. This one really piqued my interest for several reasons. As always, I made it clear that I would provide an honest review. What’s interesting to me is that my opinion changed as I read more of the book itself.
Let’s be clear: This is a well written book, authored by people for whom I have the utmost respect. I think my prejudice is more with the subject of the book - Copilot in Azure, a shining example of Microsoft dropping ‘copilot’ everywhere - and my previous experience in using it.
So, let’s split this post in two. First of all, my thoughts on the book, who it’s aimed at, and whether it hits it’s target. Then we can talk where I have concerns about the effectiveness of Copilot itself, which I think is the heart of my cynicism when I picked up the book and begain reading.
Part One: The review
This is a book designed to help the reader get the best from the Copilot now available in the Azure Portal. It takes a laudable approach to this by tackling key areas of cloud deployment, management, and operation, and providing example prompts to solve relevant challenges that are appropriate to each chapter.
It also ties these tasks back to the Well-Architected Framework, underlines the necessity of each chapter by connecting to security risks and controls, or cost management requirements, or simple good practice. In this way it provides context for those who may be less experienced with Azure looking for Copilot to enable faster adoption and problem solving.
The book presents itself without strong opinions and is very clear whether the exercises will result in advice (usually pulled from Learn and other documentation), scripts that will achieve the objective when run by the user, or interactions that can provide direct results. In this way I think it sets the readers’ expectations well - the user is in charge and is expected to take the actions which will impact services; Copilot in it’s current form will not simply go and do things.
There is also a clear discussion about how the users’ permissions affect the capabilities of Copilot, and discussion of what role assignments will be needed for the different scenarios being discussed. The book does not simply hand-wave this important topic away and explains the need for caution when granting rights and consideration of the impact of doing so.
Overall I like the approach taken. This could so easily have turned into a copy-paste of prompt and response that delivered less value to the reader. Each chapter provides several examples of hwo to create clear instructions for Copilot and only shows the responses if there is something the reader needs to understand (like seeing the tool for the first time, or what an adaptive card might look like when Copilot can go and perform a task, if authorised).
Finally, the book also provides links to some good external resources on writing effective prompts, with samples, to help the reader continue their learning.
On balance, then, I believe this book can be a good accelerator for somebody who is new to Azure and wants to learn effective management in a hands-on way, using the latest built-in AI tooling for support, but with alignment to the accepted corpus of best practice that has been built up by experienced practitioners. I think it could also be useful for existing, more skilled users who may not have yet experimented with Copilot or who may have had subpar experiences with it in the past.
Part Two: Broader thoughts
Hands on the table, I am a sceptic when it comes to a lot of ‘AI-enabled’ software and services that are being thrown at us all. When it comes to Azure operations I think that having an assistant to support me in tasks that I may have less experience with is a great idea. When it works.
And there’s the rub. As an experienced user, I would not use Copilot to provision new resources. Nor would I use the imperative scripts it might present me with. I’ve spent a long time helping customers implement repeatable, manageable deployments using declarative infrastructure-as-code. Sure, the script might work, but how does it set the user up for success in the long term. And don’t get me started on how terrible Copilot is at certain tasks where you would hope it might really be useful, like an crafting an APIM policy.
Perhaps because of my age, I prefer to check documentation first, then take my first steps with a new technology. I’d like to know of any significant gotchas before I begin resource deployment because some things are really difficult to undo.
I worry about the loss in critical thinking skills current AI tooling may bring about, and the use cases for AI in this book are almost all focused on just that - problem solving, gathering and analysing information, forming hypotheses, and taking actions.
Conclusion
Let’s pull these two threads together. The further I read of this book, the more I realised I had to set aside my own experience to do it justice.
Do I think this is a good book? Yes. Do I think this can be helpful for a general audience? Yes. But I would strongly urge that audience to use this book as an accelerator - to help them undertake tasks more quickly, particularly new ones. But also to use it as a guide for their own leaerning and development. Sure, Copilot can come up with some simple KQL queries and look at your telemetry to help with many things, but it’s no substitute for your own skills and insights and experience with your own application data. Yes, it can create scripts to deploy and update services, but it won’t replace robust automation and you should use these scripts as stepping stones to learning how to write your own.
In the end, David Rendón and Steve Miles wrote a book that made me think. I don’t know that it was their intention, but in the end it was a good thing.