Hot take time, I'm just not a yet a fan of Power Platform Copilot, hear me out.
For starters I like Github Copilot, that makes sense to me. Helping do boilerplate code like classes, objects and test scripts, is a time saver. And the ability to predict code and autocomplete is again a great time saver.
So what's wrong with Power Platform Copilot, well when Github is used like in Power Platform (when you ask a question), it provides an explanation why, and you need to copy it in. This way you learn and you have to implement it, with Power Platform it does it all for you. This feels more like an autopilot than a copilot.
So it's an autopilot, it's still helpful I hear you saying, but there is an issue with that approach, its duplicating the benefits of LowCode.
- Save time on schemas - Parse JSON from sample
- Testing - Record with Test studio
- Quicker code blocks - Components and actions
So for me Copilot is trying to solve the same thing as LowCode, deliver solutions but with less technical knowledge. So why not a copilot/autopilot on LowCode, even easier solutions has to be better, well no, and there are a few key reasons.
- Simpler Tools Lead to Complexity
- Challenge and Learning Curve Drives Innovation
- Diverse Code Pool
- Over Saturation
- Technical Debt
1. Simpler Tools Lead to Complexity
One of the biggest challenges with LowCode is the simplified language. 80% of time you only need 20% of the code. So LowCode quite rightly target that 20%, this is great when LowCode is focused on the 80%. The problem is it is never focused, once used successfully for the 80% it inevitability starts getting used on the last 20%. Here there is no right component or action, so the developer has to create ever complex, over engineered solutions. Copilot will exasperate the problem, as its most likely only right for 60-70% of solutions at the moment, but magnitudes quicker and easier to use.
2. Challenge and Learning Cover Drives Innovation
Without a learning curve things can become stagnant, everyone follows the easy path, because that's the productive way. But for me a learning curve is crucial for innovation. Having different people solve a problem in different ways creates new and exciting solutions to build on. That just doesn't happen if the computer solves your problem for you.
3. Diverse Code Pool
Similar to the above a diverse code pool is critical. This is already a problem with NoCode (LowCode not so much), but Copilot will amplify it. If everyone uses the same code to solve the same problem, then any issues (like performance or even vulnerabilities) becomes an epidemic (just look at Log4J for impact of widely spread exploit). And vulnerabilities will be more prevalent, as the hackers will congregate on these limited opportunities. You may think that LowCode or NoCode has no vulnerabilities because of the lack of code, but that isn't the case. There are lots of different type of vulnerabilities, check out my blogs:
4. Over Saturation
This is probably one you never thought about, but what is the sweet spot for number of developers? The more the better, well no, because:
- How do you find the quality in the noise
- How do divert support resources to the right solutions
- What negative brand impact poorly built solutions are
- Costs of resources for monitoring and hosting these solutions
- Loss of productivity from Citizen developers not doing their day job
So not having a barrier to entry, that small challenge of a learning curve could be a negative, as all the talent developers will get lost in the noise of people creating rubbish.
5. Technical Debt
And this is the big one, imagine asking copilot to create you a table and do x. Would the developer know where the table is, would they know security roles, would they know what fields are indexed. And if they dont know the above how hard would it be to debug and/or add new features.
Having a learning curve forces the developer to understand what they make. That knowledge is key, occasionally working with other peoples code/solutions is bad enough, imagine only working with others code/solutions.
For me I would love to see Microsoft 2 do 2 things.
First change Copilot to be like Github, explain how to do it and why, they can even add it to the clipboard to paste it in if you want it (if they ever get around to adding copy and paste to the new UI, come on Microsoft sort this out!).
Second focus on the other end, allowing LowCode developers to grow into ProCode with more customizations.
I would love to see improvements to Power Apps component framework - component certification so don't have to open up entire environment, built in code scanning etc. And for Power Automate custom code actions like in Logic Apps, so that JavaScript etc can be added to flows.
I know there are a lot of Copilot fans out there, and I am too, I just don't like its implementation and I think it should be less of a priority when it comes to LowCode.
Top comments (5)
I like your article, I think is very insightful about what Copilot is bringing to us. However, I don't see most of your points that are related with Copilot in specific.
Let me explain better coming back to old days, for example, when Visual Basic 6 appeared and all could be done with the UI, you could place a button in a specific place, doing double click you were able to code just for that event, and so on. This was a simplification of how to code an application resulting in less effort, better time-to-market, and let developers focus on the important thing. Security was nothing to worry about, more complexity appeared due to complex requirements, and so on.
What I mean is that every simplification of coding with new tools will throw us to underestimate the implementation of important things like security, performance, technical debt (from Copilot or any other source), etc. However, this will always be there and as developers (or coders or engineers or whatever title we want to use) have the responsibility to take them into account using what we have at hand.
As an example, we cannot struggle with Power Apps because it is not following the right responsive approach and try to modify the corresponding CSS, or the corresponding javascript code. It's something we have to assume and keep working without worrying so much about it or bring the platform to the its limit and inform Microsoft about the issues we found.😉
Wrapping up, I won't blame Copilot for being the tool that will come more developers to the platform because it's easing the development process and will bring issues that newbies are not concerned about them. It's something that more experienced people have to push them in order to keep doing great software, independently of the tool, platform or technology.
Totally agree, Copilot (and LowCode in general) allow removing complexity is great, and the right direction for the future. I also do love Copilot, but with the power to create amazing solutions comes responsibility, and if we make it too easy without any effort, then people will not own that responsibility.
Copilot is the future, I just hope it's more like VS code implementations
By the way, your second chapter titled "Challenge and Learning Cover Drives Innovation" is one of the best paragraphs I learned about the aim of learning new things.
Congrats!!!!!
Thank you 😊
@wyattdave : Very interesting take on Power Platform Copilot! I agree that it feels more like an autopilot than a copilot. The balance between simplicity and complexity is crucial, and your insights on learning curves and diverse code pools are spot-on. 👏🤖”