Forem: Ethiel ADIASSA

LucidClip — Building a production-grade desktop clipboard manager with faster iteration using GitHub Copilot CLI

Ethiel ADIASSA — Mon, 16 Feb 2026 04:25:13 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I built LucidClip, a production-grade, privacy-first clipboard manager for macOS designed for developers and power users.

Clipboard interaction is one of the most frequent workflows on any system, yet most solutions compromise performance, privacy, or UX discipline.

LucidClip was engineered with strict architectural constraints:

Local-first data model, clipboard history remains on-device
Predictable performance, optimized for instant retrieval
Clean architecture boundaries: UI, domain, and persistence are clearly separated
Production reliability, designed for real-world desktop runtime conditions

LucidClip is a commercial desktop application and its core implementation is private.

Website: https://lucidclip.app

Platform: macOS/Windows Desktop Application

Status: Production-ready

This project required solving real-world engineering challenges across system integration, runtime behavior, packaging, and release workflows.

Demo

Product walkthrough:

Video walkthrough (recommended): Demo
Download / Install instructions: Download and Install
LucidClip is accessible via CMD + Shift + L shortcut after installation. Use the shortcut to toggle its window.

The demo shows:

Real-time clipboard capture
Instant search and retrieval
Fast interaction loop
Stable production runtime behavior

This reflects real production usage.

My Experience with GitHub Copilot CLI

I used GitHub Copilot CLI as a “terminal-native pair engineer”, not to replace engineering judgment, but to compress iteration loops across exploration, debugging, and documentation.

1) Turning unknowns into executable options

When facing ambiguous implementation choices (e.g., macOS permissions, packaging constraints, CI friction), Copilot CLI helped me quickly produce decision options I could validate:

Explain what this error means and likely root causes
Propose 3 fixes ordered by probability and risk
Generate a minimal reproduction strategy

Result: less time stuck in “search-and-guess”, more time in testable hypotheses.

2) Debugging with structured terminal conversations

For build/packaging errors, Copilot CLI was effective at:

interpreting verbose logs,
suggesting targeted checks (paths, entitlements, sandboxing, signing),
proposing remediation steps in an order that matches how macOS builds actually fail.

This was especially useful because desktop failures are often environmental, not purely code-level.

3) Accelerating “boring but critical” engineering work

Copilot CLI shined for high-leverage tasks that are essential but time-consuming:

release notes drafts,
changelog formatting,
installation docs,
test plans,
“how to reproduce” steps for issues.

In practice, it reduced overhead and improved clarity, which directly improves maintainability and judgeability.

4) Where I did NOT rely on Copilot

I intentionally kept core decisions human-driven:

architecture boundaries,
product UX trade-offs,
privacy posture,
feature prioritization.

Copilot CLI accelerated execution, but the “shape” of the product stayed intentional.

Summary

LucidClip represents a complete production-grade desktop engineering effort, spanning architecture, system integration, debugging, packaging, and release.

GitHub Copilot CLI played a meaningful role in accelerating iteration, reducing debugging friction, and improving overall engineering throughput.

Its greatest strength lies in helping engineers move faster through uncertainty, particularly at the system and operational level.

This allowed development effort to remain focused on architecture, performance, and product quality, where engineering precision delivers the most impact.

Thanks for reviewing. I’m happy to answer any technical questions about macOS desktop architecture, privacy constraints, or product design trade-offs.

Always depend on Abstractions, a Dart example.

Ethiel ADIASSA — Mon, 15 Jan 2024 13:18:19 +0000

Abstractions provide a layer of separation between complex underlying details and higher-level functionalities.

In Software Engineering it is always stated and recommended to depend on abstractions rather than concretions. It means your modules should not rely on concrete implementations, on the contrary, they must know no implementation details, complexity, or underlying mechanism of their dependencies. This complies with the Dependency Inversion Principle (DIP) of SOLID.

By programming to abstractions rather than concrete implementations, Dart developers can

create code that is decoupled and easy to maintain;
write more reusable code by encapsulating common functionalities;
write unit tests easily and efficiently ;
write code adaptable to change, shielded from the need to make extensive changes throughout the codebase.

Now, let's dive into a practical example with explanations. For this, we'll use Dart programming language.

Let's say you were to write a simple app to send SMS keeping in mind the principle we've seen above.

abstract class SmsSender {

   void sendSms({String from, String to});
}

First, we have an abstraction of our SMS sender, it sets common functionalities every SMS sender should have. This is an abstract class and cannot be instantiated, but every SmsSender (child) should implement the sendSms method and define its low-level implementation details.

class TwilioSender implements SmsSender {

   @override
   void sendSms({String from, String to})
   {
    //your sms complex logic :)
   }
}

The TwilioSender is a SmsSender, hence must implement sendSms method. It can be used interchangeably with its parent class without any unexpected behavior.

class SmsService {

  final SmsSender smsSender;

   SmsService({
     required this.smsSender,
  });


   void sendSms({String from, String to})
   {
     smsSender.sendSms(from: from, to: to);
   }
}

Now, we have a dedicated service to send an SMS that depends on our abstract SmsSender class, which can be a Twilio sender or any of your choice. This is called Dependency Injection. This is the most important aspect since the SmsService module doesn't depend on any concrete implementation of SmsSender. This enables further scalability and adaptability to change.

Let's see a simple usage of those classes.

NB: I'm not using a dedicated dependency injection library and leaving some implementations for the sake of simplicity

 void main(){

  //inject TwilioSender inside SmsService
  SmsService = SmsService(TwilioSender());

  smsService.sendSms(to: '+22809453945', from: '+2250503244804')

}

The TwilioSender can easily be replaced later by any other SMS sender. The SmsService doesn't and needs not to know the implementation details of an SMS sender, it simply wants to send an SMS.

That's the beauty of this principle.

In the complex and ever-changing field of software engineering, embracing abstractions is not merely a convenience but a necessity. Abstractions simplify complexity, enhance productivity, promote code reusability, and contribute to the maintainability and scalability of software systems.

I hope you understand and will keep in mind this in your coding endeavor.

Intro to ValueNotifier, a simple yet efficient state management for Flutter apps.

Ethiel ADIASSA — Sun, 14 May 2023 05:03:10 +0000

Today, I'd like to talk to you about simple and reactive state management in Flutter with ValueNotifier.

State management is an essential part of building any Flutter application, and there are several state management solutions available, such as Riverpod, Provider, Bloc, Redux, etc. However, in some cases, you may find that these solutions are too complex for your needs, and you'd prefer a simpler and more lightweight option. This is where ValueNotifier comes in.

ValueNotifier is a simple class that extends ChangeNotifier and provides a way to store a single value that can be listened to and updated reactively. It's perfect for simple state management needs and can be used with widgets that need to be rebuilt when the state changes.

Here's a simple implementation example:


import 'package:flutter/material.dart';

class CounterModel extends ValueNotifier<int> {
  CounterModel(int value) : super(value);

  void increment() => value++;
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final counter = CounterModel(0);

    return MaterialApp(
      title: 'ValueNotifier Demo',
      home: Scaffold(
        appBar: AppBar(
          title: Text('ValueNotifier Demo'),
        ),
        body: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              Text(
                'You have pushed the button this many times:',
              ),
              ValueListenableBuilder(
                valueListenable: counter,
                builder: (BuildContext context, int value, Widget child) {
                  return Text(
                    '$value',
                    style: Theme.of(context).textTheme.headline4,
                  );
                },
              ),
            ],
          ),
        ),
        floatingActionButton: FloatingActionButton(
          onPressed: () {
            counter.increment();
          },
          tooltip: 'Increment',
          child: Icon(Icons.add),
        ),
      ),
    );
  }
}

In this example,

we define a CounterModel class that extends ValueNotifier and provides an increment() method to update the counter value;
we then create an instance of CounterModel and pass it to the ValueListenableBuilder widget, which listens to changes in the counter value and rebuilds the widget tree whenever the value changes.

Using ValueNotifier is that simple! It's a great choice for small to medium-sized projects where you don't need the complexity of other state management solutions. However, keep in mind that it may not be suitable for larger projects or projects with complex state management needs.

In conclusion, ValueNotifier is a simple and reactive way to manage state in your Flutter applications. It's easy to use and perfect for small to medium-sized projects. If you need something more powerful, there are several other state management solutions available in the Flutter ecosystem.
I'll be writing soon a more advanced use case of the state management with ValueNotifier in real-world projects.

Practical Intro to Operator Overloading in Dart

Ethiel ADIASSA — Wed, 03 May 2023 01:28:04 +0000

Introduction

Operator overloading is a quite powerful, popular, and common concept and feature in Object Oriented world. For people not familiar with that, it allows developers to redefine and customize the behavior of standard operators(+,-,%, etc) when used on user-created objects.
Several object-oriented languages (like Dart, Java, C++,...) come with built-in support for it.

In traditional programming, these operators are defined to work with built-in data types such as integers, floats, and strings. However, operator overloading allows you to define the behavior of these operators on your own objects. For example, if you have a class that represents complex numbers, you can define how the addition and subtraction operators work on instances of that class.

How it works

Syntax

ClassRoom operator + (Object o){
  //Your logic here
}

Here are some key points to note about the syntax:

the reserved keyword operator and the specific operator we want to overload: the plus operator in this case: +;
the operands: Object o is the right-hand side operand and the class we overload the operator on is the left-hand side one;
the return type ClassRoom the function should return.

Now that the concepts and syntax are clearly defined, let's get to a practical example. Let's assume we have a classroom with some students we want to keep track of. We also want to add new students to the classroom.

We should have one class to represent the ClassRoom and another one for the User.

class ClassRoom {
  final List<Student> students;

  ClassRoom(this.students);
}

class Student {
  final String name;
  final int age;

  Student(this.name, this.age);

  @override
  String toString() {
    return 'Student{name: $name age: $age}';
  }
}

Let's overload the + operator to fit our use case.

ClassRoom operator + (List<Student> others){
    List<Student> students = [this,...others];
    return ClassRoom(students);
}

Now your Student class should look like the following:

class Student {
  final String name;
  final int age;

  Student(this.name, this.age);

  ClassRoom operator + (List<Student> others){
    List<Student> students = [this,...others];
    return ClassRoom(students);
  }

  @override
  String toString() {
    return 'Student{name: $name, age: $age}';
  }
}

the reserved keyword operator and the specific operator we want to overload: the plus operator in this case: +;
the return type ClassRoom, we add the current student to the list of the students and return it.

From now on, every time we can use the plus operator like the following:

ClassRoom classRoom =  Student("Andrew",20) + [Student("John",14) ,  Student("Jane", 13)] ;

And if we print the classRoom object, we should get:

[Student{name: Andrew, age: 20}, Student{name: John, age: 14}, Student{name: Jane, age: 13}]

Another example

Now let's want to get the older student of the classroom. This will get us to overload another operator, it can be > or < depending on your preference. We'll go with > for simplicity.

Student operator > (Student other){
    return age > other.age ? this : other;
}

The syntax is pretty much the same.

the reserved keyword operator and the specific overloaded operator >;
the return type Student, we want to return the oldest student so we compare the current student's age with his comrade's one and return the greatest one.

Now we can use our operator like the following:

Student oldest= classRoom.students.reduce((prev, student)=> prev > student );

The reduce method reduces a list to a single value based on the provided function. We return the oldest student in the class room.

If we print oldest, we should get the expected result:

Student{name: Andrew, age: 20}

Conclusion

With those above examples we have seen how powerful operator overloading is and how concise and easier to read it can make our code by allowing you to use familiar operators with our custom objects. However, it's important to use operator overloading judiciously and with care, as it can lead to code that is difficult to understand and maintain if overused or used incorrectly.
For additional resources you can head to the following links:

Acknowledgments

Thanks to the author of this article since he's inspired mine.

Smooth transition with text styles in Flutter

Ethiel ADIASSA — Thu, 05 Sep 2019 23:56:53 +0000

Hey folks! In this short article, I'll be showing you how to add a smooth transition between styles of the same text widget for example.

First let's declare the initial style:

final TextStyle initialStyle = TextStyle(
  fontSize: 20.0,
  color: Colors.grey,
  fontWeight: FontWeight.bold,
);

Then the final style:

final TextStyle finalStyle = TextStyle(
  fontSize: 22.0,
  color: Colors.black,
  fontWeight: FontWeight.bold,
);

We'll also use a boolean to handle the state of our text widget, whether it's tapped or not:

var isTapped = false;

Then, wrap the text widget inside the AnimatedDefaultTextStyle widget to enable a transition between your styles. Last, you can wrap all this in the InkWell widget with the boolean to switch between the styles on tap.

InkWell(
        onTap: isTapped = !isTapped,
        child: AnimatedDefaultTextStyle(
          style: isTapped ? finalStyle : finalStyle,
          duration: const Duration(milliseconds: 500),
          child: Text(
           "Hello World"
          ),
        ),
      )

The image below summarizes all.

That's all for this post. Thanks for your attention :)

Handle widgets visibility easily in Flutter

Ethiel ADIASSA — Fri, 10 May 2019 13:21:30 +0000

When it comes to manage your widgets visibility in Flutter, you have many options. Flutter provides us with some cool widgets for this purpose. Let's look at them :)

Let's say you want to hide the following widget.

const child = Text("Hello World");

1. Use Opacity widget



    Opacity(
      opacity: 0.0,
      child: Container(
          child: child
      )
    );

This widget simply sets the child's opacity to zero but still renders it. So the child is hidden but takes space and you can interact with it.

2. Use Offstage widget



    Offstage(
      offstage: true,
      child: child
      )
    );

Offstage renders the child widget off set the screen. This means that the widget is not rendered in the subtree and so doesn't take any space.

3. Use Visibility widget



    Visibility(
      visible: false,
      child: child
      )
    );

Here the child widget is not rendered in the subtree, and Flutter uses instead a shrinked sized box to replace it. The result is pretty much the same as with Offstage.

Use whatever you want as per as your needs.

The image below summarizes all.

That's all for this post. Thanks :)