3个爪哇冠军如何利用GitHub Copilot来提高生产力

3个爪哇冠军如何利用GitHub Copilot来提高生产力

三个爪哇冠军分享如何使用GitHub Copilot解决问题，加速发展，让人类对结果负责。

AI编码工具可以快速生成代码，但单靠速度并不能解决最难的软件工程问题。 开发者仍然需要提供背景，验证结果，保护可维护性，并继续对船舶负责。

为了了解经验丰富的开发者是如何实现这种平衡的，我们与三个Java冠军进行了交谈，所有的人都拥有十多年的Java使用经验。 他们分享了生产中使用GitHub Copilot和开源的具体例子，以及他们用来将AI生成的输出转化为可靠软件的做法。

这是他们分享给我们的提示。

弗拉德·米哈尔恰

GitHub简介：@vladmihalcea

GitHub Copilot最近怎么帮你的？

我用它来分析、设计和执行超强抗争的Utils和超强抗争的Optizer。

例如，我很久以来一直希望开发一个网络应用程序，提供优化事件历史，在大赦国际之前，我一直推迟这项任务，因为要花几周时间才能发展起来。 但是使用Copilot就像有了一个新的团队成员，所以我用它来创建一个应用程序，在下一个版本的Hypersistence Optimizer中可以发运。 这项工作不是几个星期，而是仅仅用了两天时间来执行。

你们的典型用法是什么？您是使用 GitHub Copilot 作为 IDE 插件还是 GitHub Copilot 应用程序？

我使用GitHub Copilot在IntelliJEIDA中

协助我加速调查，为需要验证的特性建立原型。

因为他们的目标是提高我的生产力，而不是完全取代我。 虽然大赦国际在许多情况中提供了正确的答案，但有时答复并不令人满意，需要我的干预。

你能分享一些小费和最佳做法吗？例如，你用的是哪些技能？

我创造了自己的技能这样Copilot生成的文本看起来像是我亲手写的

这技能从我发表的文章中捕捉到65篇我的声音，在为这个项目生成文件时，这确实很有用，因为它让LLM从12年的博客学习

我从一个软件工程师的职业生涯中得知，我们花在代码维护上的时间远多于创建。 因此，由于维持和稳定对现有产品至关重要，我开发了帮助AI按照最不惊讶的原则模仿现有代码惯例的技能。

一个提示是根据操作类型改变模型类型。 为了彻底的思考，我使用Opus 与100万上下文窗口和Extra High或Max推理。 然而，对于更简单的任务，如生成报告，释放指出，或者验证文档，我使用消耗更少的代币的较轻模型。

帕特里克·鲍姆加特纳

GitHub简介：@ patbaumgartner

你的工作涉及辅导队你有什么办法？

我的许多工作都发生在正常的生意还得继续运转的时候。 你不能在六个月内停止一切“转变 ”。 我们通常首先共同解决眼前的问题，了解小组目前的状况，确定我们想要去的地方以及我们如何知道我们正在改进，然后一步一步地向那里推进。

根据具体情况，这可以指：软件工艺做法，如TDD，重构，连续交付和XP；架构和模块化与Spring Boot,Spring Modulith; Spring Security；优化Java和Spring Boot对容器的应用；或越来越多的代理工程。

对我很重要的是，我与团队合作。 我们一起做决定我不想团队依赖我。 理想的情况是，过了一段时间后，他们就不再需要我了除了作为参赛伙伴

也许这解释了为什么我发现新一代的AI工具如此有趣：我喜欢与人合作，学习，实验，解决问题。 AI给了我们另一个非常强大的工具来做到这一点。

你能分享一个很好的故事关于GitHub Copilot如何帮助你最近？

其实有三个非常不同的例子改变了我与GitHub Copilot合作的想法。

让我们从第一个开始。

一是将大约900个教学幻灯片从Reveal.js到Marp的15个演示文稿。 这些不是简单的幻灯片。 许多包含代码，动画，甚至互动的例子，我可以在教学时改变JavaScript的活性。 更重要的是，这些介绍已经与学生进行了战斗测试。 流量有效。 丢掉一块小东西会打破我在课堂上的故事。

人工迁移可能需要我一周或更长时间

用Copilot，我处理它的方式不同。 我们首先分析现有材料，确定目标，制定移民计划，确定限制，提供例子，并确定必须保持完好无损的内容。 然后我们从巨大的结构变化变成了细节。

真正重要的是核查。

我们制作了Reveal.js和Marp版本的截图，并以视觉和算法方式加以比较。 我们建了一个小应用程序，我可以运行两个幻灯片甲板在彼此旁边手动验证动画。 我们甚至比较了生成的PDF.

这意味着agent不只是说“移民完成”。 我们有证据

整个迁移过程花了我大约8到10个小时。 我仍然拥有内容，教学意图，和每一个有意义的变化。 Copilot可以自动修正一个打字功能，但如果内容，版本，日期或含义发生变化，那就是我们讨论过的问题。

对我来说，这一经历加强了一项重要原则：授权执行，而不是责任。 结果是我自己的

你能分享第二个例子吗？

第二个例子是用Tamboui建造终端UI应用程序。 它最初在WSL下的Linux运行完美，我完全忘记有人可能直接在Windows CMD或PowerShell运行。

然后一个真正的用户做到了。

他们发现Enter键在某些形式上被简单地忽略了。 这也是我坚信的另一个原则：早期的船舶软件，因为你从人们如何实际使用它那里学到了。

我们用Copilot将反馈转化为可复制的UI测试。 在Linux上，Copilot正在用tmux导航应用程序。 通过与它合作，我了解了psmux，并且可以在PowerShell执行类似的流量。 我们复制了这个问题，创造了一个局部的固定，把真正的问题追溯到坦布伊，我提交了上游的固定，它被合并了。

在这项工作中，测试说明本身对于现有背景来说太大了。 所以我请Copilot帮我重新设计测试的表述方式。 它不包含包含识别符，名称和重复描述的动词表，而是提出一个更紧凑的箭头符号：步步输入，只有关键时才有附加信息。

这让我吃惊。 我们不只是利用AI来执行信息；我们正在共同努力，探讨如何将信息用于执行。 它不必是对人类最大的友好。 它在为agent高效的同时必须保留语义。

第三个例子怎么样？

第三个例子又完全不同。

和我关系密切的人需要练习数学，我想：我们为什么不建立一个小型的学习应用？

它包括加、减、乘、分和分，其余为一至四年级。 但我不想再做一个简单的测验与Copilot一起，我研究了一些学习方法，如间距重复，即时反馈，适应性难度，动机，合作学习和没有黑暗模式的游戏。

有趣的是，在那次研究中，Copilot挑战了我最初的一个假设。 我起初希望这个申请是通用的，适用于各地儿童。 研究导致我们转向实际的学校课程。 我意识到，议题是推出的顺序、操作和数量范围差别很大，因此立即使其“普遍”是不必要的。

因此，我们首先关注瑞士，并相应调整进展。 由于瑞士是多语种国家，该应用程序有德语，法语，意大利语和英语版本。

它还有合作和竞争的双玩家模式，当有人得到一个答案错误时，应用程序解释一个方法来解决它，带来类似问题通过空格重复返回。

我故意选择了一个没有后端的建筑。 我没有理由在服务器上收集儿童的个人数据，所以数据留在设备上，应用程序可以简单地在GitHub Pages上托管。

一开始作为一个小实验，现在被朋友使用和分享。 它不小心变成了一个小产品。

这段经历让我看到了Copilot的另一面：不要仅仅用它来实施你的解决方案。 在开始建设前，用它作为参赛伙伴来拓展和挑战解析空间。

您通常如何使用 Copilot?

我不再使用经典的Copilot自动完成体验。

我的作品几乎完全转向代理工作流程。

当我需要紧凑的视觉反馈循环时，我就会使用VS代码—— 当我想仔细查看文件、代码、演示文稿或中间结果时

对于更大的执行导向任务，我经常与来自终端的编码agent合作。 在那里，我更舒服的授权一块工作，让它执行，然后检查完整的结果。 我选择的接口主要取决于我所需要的反馈循环。

在前往JavaLand期间，我还通过GitHub的编码-agent工作流程，获得了令人着迷的经验。 我开始探索一个 Maven 插件的构思，它选择了 Spring Boot 自动配置被装入的插件。 在大约四个小时的旅程中，我从我的电话中引导agent：给它一个任务，回顾它做了什么，思考下一步，发送下一个指令。

当我到达的时候，我有一个工作用的马文插件，一个CI管道，一个样品应用的性能测试，以及能够证明优化是否实际有效的报告。

那是我第一次这样工作，我感到惊讶的是，它实际上奏效了。 我不是想用手机写Java。 在agent被处决时，我正在审查、决定和指导。

我还使用MCP服务器，当它们给了我有用的能力或上下文。 例如，我用Case7来进行文献整理，与我的Logseq知识库进行整合，我用MCP集成实验来进行Adobe Premiere Pro.

但我不只因为我能使用MCP。 如果有一个好的CLI存在，我经常更喜欢CLI，因为它感觉对我更直接，更快。

agent在我的精神模型中也不是“初级开发者”。 我更认为这是个参赛搭档但是，就像任何人参加一个项目一样，它首先需要提高速度。

上下文为王。

你能分享一些小费和最佳做法吗？

我建议最大的事情是：停止一弹一弹的提示。

对于任何非部落性的东西，我想在处决开始前了解问题。 我经常明确要求agent进入

本文由 AI图鉴自动抓取并翻译，版权归原作者所有；如需查看原文请点下方链接。

How 3 Java Champions are using GitHub Copilot for increased productivity

Three Java Champions share how they use GitHub Copilot to solve problems, accelerate development, and keep humans responsible for the results.

AI coding tools can generate code quickly, but speed alone does not solve the hardest software engineering problems. Developers still need to provide context, validate results, protect maintainability, and remain accountable for what ships.

To learn how experienced developers strike that balance, we spoke with three Java Champions, all with over a decade of experience in using Java. They shared concrete examples of using GitHub Copilot in production and open source, along with the practices they use to turn AI-generated output into reliable software.

Here are the tips they shared with us.

Vlad Mihalcea

GitHub profile: @vladmihalcea

How has GitHub Copilot helped you recently?

I’ve been using it to analyze, design, and implement various features in both Hypersistence Utils and Hypersistence Optimizer.

For example, I’ve been wanting for a long time to develop a web application that provides Optimizer event history so we can see how performance improvement efforts are materializing in application performance. Before AI, I kept postponing this task because it would have taken me weeks to develop. But using Copilot is like having a new team member, so I used it to create an app that will ship in the next version of Hypersistence Optimizer. Instead of weeks, this task took just two days to implement.

What’s your typical usage? Are you using GitHub Copilot as an IDE plugin or the GitHub Copilot app?

I use GitHub Copilot in IntelliJ IDEA because it’s convenient to run while reviewing source code or during a debug session.

It’s very useful as a code assistant, and it helps me speed up both investigations and building prototypes for features that need validation.

I still review the plans and the code that is generated by AI since their goal is to improve my productivity, not replace me entirely. While AI provides the right answer in many situations, there are still times when the response is not satisfactory and requires my intervention.

Can you share some tips and best practices? For example, which skills are you using?

I created my own skills so that whatever text Copilot generates looks like something I wrote by hand.

This skill captures my voice from 65 of my published articles, so a draft comes back sounding like my blog instead of like a language model. This is really useful when generating documentation for this project, since it lets the LLM learn from 12 years of blogging and provide examples that follow the same principles, such as expressiveness, testability, and simplicity.

Throughout my career as a software engineer, I’ve learned that we spend far more time on code maintenance than on creating it. Therefore, because maintenance and stability are critical for existing products, I developed skills that help AI mimic existing code practices in accordance with the principle of least astonishment.

One tip is to change the model type based on the type of operation. For thorough thinking, I use Opus with the 1 million context window and Extra High or Max reasoning. However, for simpler tasks, such as generating reports, release notes, or verifying documentation, I use lighter models that consume fewer tokens.

Patrick Baumgartner

GitHub profile: @patbaumgartner

Your work involves coaching teams. What is your approach?

A lot of my work happens while the normal business still has to keep running. You cannot stop everything for six months to “transform.” We usually start by solving immediate problems together, understand where the team currently stands, define where we want to go and how we will know that we are improving, and then move there step by step.

Depending on the situation, that can mean Software Craft practices such as TDD, refactoring, continuous delivery and XP; architecture and modularisation with Spring Boot, Spring Modulith; Spring Security; optimising Java and Spring Boot applications for containers; or increasingly, agentic engineering.

The important part for me is that I work with the team. We make decisions together. I don’t want a team to become dependent on me. Ideally, after some time they no longer need me except perhaps as a sparring partner.

And maybe that explains why I find this new generation of AI tools so interesting: I like working with people, learning, experimenting, and solving problems. AI gives us another very powerful tool for doing exactly that.

Can you share a good story about how GitHub Copilot has helped you recently?

There are actually three very different examples that changed how I think about working with GitHub Copilot.

Let’s start with the first one.

One was a migration of around 900 teaching slides across 15 presentations from Reveal.js to Marp. These were not simple slides. Many contain code, animations, and even interactive examples where I can change JavaScript live while teaching. More importantly, the presentations had already been battle-tested with students. The flow worked. Losing one small piece could break the story I use in the classroom.

Doing that migration manually would probably have taken me a week or more—and realistically, I might simply have avoided doing it because it was such tedious work.

With Copilot, I approached it differently. We first analysed the existing material, defined the target, created a migration plan, established constraints, provided examples, and defined what had to remain intact. Then we worked from the big structural changes down into the details.

The really important part was verification.

We generated screenshots of the Reveal.js and Marp versions and compared them visually and algorithmically. We built a small application where I could run both slide decks next to each other to verify animations manually. We even compared the generated PDFs.

That meant the agent did not just say, “Migration complete.” We had evidence.

The entire migration took me roughly eight to ten hours. I still owned the content, the teaching intent, and every meaningful change. Copilot could fix a typo automatically, but if content, versions, dates or meaning changed, that was something we discussed.

For me, that experience reinforced an important principle: delegate execution, not responsibility. I own the result.

Can you share the second example?

A second example came from building a terminal UI application with Tamboui. It initially worked perfectly in Linux under WSL, and I had completely forgotten that somebody might run it directly in Windows CMD or PowerShell.

And then a real user did.

They discovered that the Enter key was simply ignored in some forms. That is another principle I strongly believe in: ship software early, because you learn from how people actually use it.

We used Copilot to turn that feedback into reproducible UI tests. On Linux, Copilot was navigating the application with tmux. Through working with it, I learned about psmux and could execute similar flows in PowerShell. We reproduced the problem, created a local fix, traced the real problem into Tamboui, and I submitted the upstream fix, which was merged.

During this work, the test descriptions themselves became too large for the available context. So I asked Copilot to help me redesign the way the tests were represented. Instead of verbose tables containing identifiers, names and repeated descriptions, it proposed a much more compact arrow notation: step → step → input, with additional information only where it was critical.

That surprised me. We were not just using AI to execute information; we were working together on how information should be represented for execution. It did not have to be maximally human-friendly. It had to preserve the semantics while being efficient for the agent.

How about the third example?

The third example is completely different again.

Someone close to me needed to practise mathematics, and I thought: why don’t we build a small learning app?

It covers addition, subtraction, multiplication, division and division with remainder for grades one through four. But I did not want to build another simple quiz application. Together with Copilot, I researched learning approaches such as spaced repetition, immediate feedback, adaptive difficulty, motivation, cooperative learning and gamification without dark patterns.

Interestingly, during that research Copilot challenged one of my original assumptions. I initially wanted the application to be generic for children everywhere. The research led us toward looking at the actual school curriculum instead. I realised that the order in which topics are introduced, the operations and number ranges differ enough that making it “universal” immediately was unnecessary.

So we focused on Switzerland first and aligned the progression accordingly. Because Switzerland is multilingual, the application is available in German, French, Italian and English.

It also has cooperative and competitive two-player modes, and when someone gets an answer wrong, the application explains one way to solve it and brings similar questions back through spaced repetition.

I deliberately chose an architecture without a backend. There is no reason for me to collect children’s personal data on a server, so the data stays on the device and the application can simply be hosted on GitHub Pages.

What started as a small experiment is now being used and shared among friends. It accidentally became a little product.

That experience showed me another side of Copilot: don’t only use it to implement your solution. Use it as a sparring partner to expand and challenge the solution space before you start building.

How do you typically use Copilot?

I actually don’t use the classic Copilot autocomplete experience anymore.

My work has moved almost completely toward agentic workflows.

I use VS Code when I need a tight visual feedback loop—when I want to look closely at documents, code, presentations or intermediate results and adapt the process as I go.

For larger execution-oriented tasks, I often work with the coding agent from the terminal. There I am more comfortable delegating a piece of work, letting it execute, and then inspecting the complete result. The interface I choose depends mostly on the feedback loop I need.

I also had a fascinating experience using the coding-agent workflow through GitHub while travelling to JavaLand. I had started exploring an idea for a Maven plugin that optimises which Spring Boot auto-configurations are loaded. During roughly a four-hour journey, I was steering the agent from my phone: giving it a task, reviewing what it had done, thinking about the next step, and sending the next instruction.

By the time I arrived, I had a working Maven plugin, a CI pipeline, performance tests against a sample application, and reports that could demonstrate whether the optimisation actually worked.

That was the first time I had worked that way, and I was amazed that it actually worked. I wasn’t trying to write Java on my phone. I was reviewing, deciding and steering while the agent executed.

I also use MCP servers when they give me useful capabilities or context. For example, I have used Context7 for documentation, integrations with my Logseq knowledge base, and I have experimented with an MCP integration for Adobe Premiere Pro.

But I don’t use MCP just because I can. If a good CLI exists, I often prefer the CLI because it feels more direct and faster to me.

The agent is also not a “junior developer” in my mental model. I think of it much more as a sparring partner. But just like anyone joining a project, it first needs to be brought up to speed.

Context is king.

Can you share some tips and best practices?

The biggest thing I would recommend is: stop one-shot prompting.

For anything non-trivial, I want to understand the problem before execution starts. Quite often I explicitly ask the agent to in

Auto-fetched and translated by AI Atlas. All rights belong to the original author.